/*
    * Copyright 1999-2006 Faculty of Mathematics, Physics
    * and Informatics, Comenius University, Bratislava. This file is protected by
    * the Mozilla Public License version 1.1 (the License); you may not use this
    * file except in compliance with the License. You may obtain a copy of the
    * License at http://euromath2.sourceforge.net/license.html 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 sk.uniba.euromath.editor.textEditor.tools;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Map;
  
  import org.eclipse.draw2d.Cursors;
  import org.eclipse.draw2d.geometry.Point;
  import org.eclipse.gef.EditPart;
  import org.eclipse.gef.Request;
  import org.eclipse.gef.tools.SelectionTool;
  import org.eclipse.swt.SWT;
  import org.eclipse.swt.events.KeyEvent;
  
  import sk.baka.ikslibs.interval.DOMInterval;
  import sk.baka.ikslibs.interval.DOMIntervalSet;
  import sk.baka.ikslibs.ptr.DomPointer;
  import sk.uniba.euromath.editor.textEditor.CaretManager;
  import sk.uniba.euromath.editor.textEditor.ITextPieceKeeper;
  import sk.uniba.euromath.editor.textEditor.TextPieceContainer;
  import sk.uniba.euromath.editor.textEditor.editParts.TextEditPart;
  import sk.uniba.euromath.editor.textEditor.requests.RequestConstants;
  import sk.uniba.euromath.editor.textEditor.requests.RetargetCaretRequest;
  import sk.uniba.euromath.editor.textEditor.requests.editTextRequests.DeleteTextRequest;
  import sk.uniba.euromath.editor.textEditor.requests.editTextRequests.InsertTextRequest;
  import sk.uniba.euromath.editor.xmlEditor.viewers.IXMLGraphicalViewer;
  
  /***
   * <B>TextTool</B> - Is responsible for editing of text. Switching between
   * tools is performed by
   * <OL>
   * <LI>double-click in text. That switches StructureTool to TextTool(S -> T).
   * <LI>Ctrl+T, that swithes these tools each other(T <-> S)
   * <LI>Menu, [by icons].
   * </OL>
   * <H4> More deep in TextTool </H4>
   * <P>
   * <OL>
   * 
   * <LI>Supports caret, caret is always activated. Click of mouse in text
   * retargets caret. By clicking not directly on text, but in position where is
   * short line of text, caret is shown at the end of line. If there is not a
   * line, nothing happens. Caret is moved also by
   * keyboard(arrows,HOME,END,ctrl-a, ...).
   * 
   * <LI>Selections.
   * <OL>
   * <LI>Selections of text
   * <UL>
   * <LI>by holding <I>shift or ctrl or ...</I> and moving caret
   * <LI>by draging of mouse [+ keys]
   * </UL>
   * <LI>Selections of structure - means elements, nodes
   * <UL>
   * <LI><I>alt + scroll = deep </I> by scrolling wheel is selected the bottom
   * most element in doc containing caret or (parent or child towards caret) of
   * selected element
   * <LI><I>alt + right or left click = width</I>, selects brother of selected
   * element
   * <LI><I>alt + middleButtonClick = direct select</I>, selectes the bottom
   * most element in doc containing cursor
   * </UL>
   * </OL>
   * 
   * <LI>Undo, Redo, clipboard. Standard.
   * 
   * <LI>Editing.
   * <OL>
   * <LI>Text
   * <UL>
   * <LI>Insert - direct keypressing in editor or by <B>InsetBox</B>
   * <LI>delete - <I> del, backSpace</I> + [selection] or Menu
   * </UL>
   * <LI>Structure
   * <UL>
   * <LI>Insert,Modify - through Menu
   * <LI>delete - <I> del, backSpace</I> + [selection] or Menu
   * </UL>
   * </OL>
   * 
   * </OL>
   * </P>
   * 
   * @author Martin Kollar on 3.5.2005
   */
  
  public class TextTool extends SelectionTool {
  
     /***
      * Debug code.
      */
     private static final String CODE = "text editing"; //$NON-NLS-1$
 
     /***
      * New line break.
      */
     private static final char NEWLINE = '\n';
 
     /***
      * Standard space.
      */
     private static final char SPACE = '\u0020';
 
     /***
      * Non breakable space.
      */
     private static final char NBSPACE = '\u00A0';
 
     /***
      * Linebreak.
      */
     private static final char LINEBREAK = '\u2028';
 
     /***
      * Zero width space.
      */
     private static final char ZERO_WIDTH_SPACE = '\u200B';
 
     /***
      * Non breakable zero width space.
      */
     private static final char ZERO_WIDTH_NOBREAK_SPACE = '\uFEFF';
 
     private DOMInterval localSelection;
 
     /***
      * Caret offset when the tool created This needs to be stored because of
      * activating this Tool
      */
     private int startCaretOffset;
 
     private EditPart partUnderCaret;
 
     /***
      * handle events during transformation
      */
     private final List<KeyEvent> eventBuffer = new ArrayList<KeyEvent>();
 
     private boolean waitForRepaint;
 
     /***
      * Holds reference to caretManager.
      */
     private CaretManager caretManager;
 
     /***
      * Check if <code>character</code> can be written to text
      * 
      * @param character
      *            character to check
      * @return <code>true</code> if character can by written to text, else
      *         <code>false</code>
      */
     static public boolean acceptableText(char character) {
         return Character.isLetterOrDigit(character)
                 || Character.isSpaceChar(character)
                 || (Character.getType(character) == Character.DASH_PUNCTUATION)
                 || (Character.getType(character) == Character.START_PUNCTUATION)
                 || (Character.getType(character) == Character.END_PUNCTUATION)
                 || (Character.getType(character) == Character.CONNECTOR_PUNCTUATION)
                 || (Character.getType(character) == Character.OTHER_PUNCTUATION) // 24
                 || (Character.getType(character) == Character.MATH_SYMBOL) // 25
                 || (Character.getType(character) == Character.CURRENCY_SYMBOL)
                 || (Character.getType(character) == Character.MODIFIER_SYMBOL);
     }
 
     /***
      * @param c
      *            character to check for whitespace
      * @return <code>true</code> if character is whitespace
      */
     static public boolean isWhiteSpace(char c) {
         return ((c == SPACE) || (c == NEWLINE) || (c == NBSPACE)
                 || (c == LINEBREAK) || (c == ZERO_WIDTH_SPACE) || (c == ZERO_WIDTH_NOBREAK_SPACE));
     }
 
     /***
      * @param priorTool
      *            tool used before this one
      * @param source
      *            focused EditPart
      * @param caretOffset
      *            caret offset from start of selectionStartPart EditPart
      * @param cManager
      *            CaretManager
      */
     public TextTool(EditPart source, int caretOffset, CaretManager cManager) {
         setDefaultCursor(Cursors.IBEAM);
         setUnloadWhenFinished(false);
         this.startCaretOffset = caretOffset;
         setPartUnderCaret(source);
         this.caretManager = cManager;
         setWaitForRepaint(false);
     }
 
     /***
      * Activates Tool and Caret on <code>startCaretOffset</code>
      */
     @Override
     public void activate() {
         // TODO GUI: Here can be a problem, when Tool is deactivated, than some
         // changes happen
         // and than again activated - partUnderCaret, do not have to exist or
         // startCaretOffset can
         // be out of range
         // It could be solved like not to store EditPart and offset of Caret
         // where to be caret
         // activated, but (x,y) location - this is a problem too, because (x,y)
     	// location is relative
         super.activate();
 
         this.caretManager.activateCaret((ITextPieceKeeper) getPartUnderCaret(),
                 this.startCaretOffset);
         /*
          * Point loc = getLocation().getCopy();
          * ((ITextPieceKeeper)getActive()).getTextLocator().translateToRelative(loc);
          * 
          * int caretIndex =
          * ((ITextPieceKeeper)getActive()).getTextLocator().getCharIndexAtPos(loc);
          * 
          * sendRequest(getActive(), new
          * ActivateCaretRequest(this.startCaretOffset));
          */
     }
 
     /***
      * Deactivates Tool and Caret
      */
     @Override
     public void deactivate() {
         this.startCaretOffset = this.caretManager.getCaretOffset();
         super.deactivate();
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see org.eclipse.gef.tools.AbstractTool#getDebugName()
      */
     @Override
     protected String getDebugName() {
         return CODE;
     }
 
     /***
      * @param event
      *            KeyEvent left,right,up,down
      * 
      * @return RequestConstants.LEFT[RIGHT,UP,DOWN]
      */
     private String KeyEventToDirection(KeyEvent event) {
         if (event.character == SWT.BS)
             return RequestConstants.LEFT;
         if (event.keyCode == SWT.ARROW_LEFT)
             return RequestConstants.LEFT;
         if (event.keyCode == SWT.ARROW_RIGHT)
             return RequestConstants.RIGHT;
         if (event.keyCode == SWT.ARROW_UP)
             return RequestConstants.UP;
         if (event.keyCode == SWT.ARROW_DOWN)
             return RequestConstants.DOWN;
         if (event.keyCode == SWT.HOME)
             return RequestConstants.HOME;
         if (event.keyCode == SWT.END)
             return RequestConstants.END;
 
         throw new IllegalArgumentException();
     }
 
     /***
      * @param e
      *            Left,Right,Up,Down,Home,End KeyEvent
      */
     protected void performArrowMove(KeyEvent e) {
         this.caretManager.moveCaret(KeyEventToDirection(e));
     }
 
 
     /***
      * @param e
      */
     protected void performTextInput(KeyEvent e) {
         if ((getPartUnderCaret() == null)
                 && (!(getPartUnderCaret() instanceof ITextPieceKeeper)))
             return;
 
         ITextPieceKeeper oldTextPieceKeeper = (ITextPieceKeeper) getPartUnderCaret();
 
         InsertTextRequest textRequest = new InsertTextRequest(
                 oldTextPieceKeeper, String.valueOf(e.character),
                 this.caretManager.getCaretOffset());
 
         if (isWhiteSpace(e.character)) {
             // TODO Kollar Solve this casting to TextEditPart
             if (this.caretManager.getCaretOffset() == 0)
                 // space can not be written here because of start of line or
                 // TextNode
                 return;
 
             // TODO Kollar Solve this casting to TextEditPart
             String containerText = ((TextEditPart) oldTextPieceKeeper)
                     .getWholeContainerText();
             int index = oldTextPieceKeeper.getTextPieceInfo().getOffset()
                     + this.caretManager.getCaretOffset();
 
             if (index == containerText.length()) {
                 if (isWhiteSpace(containerText.toCharArray()[index - 1]))
                     // we are trying to write a space at the at of TextNode a
                     // the last character is space
                     return;
             } else if ((isWhiteSpace(containerText.toCharArray()[index]))
                     || (isWhiteSpace(containerText.toCharArray()[index - 1])))
                 // space can not be written here because of there can not be two
                 // adjacent spaces
                 return;
         }
 
         Point p = new Point(this.caretManager.getLocation().x,
                 oldTextPieceKeeper.getTextLocator().getTextBounds().y);
 
         int caretOffset = this.caretManager.getCaretOffset();
         RetargetCaretRequest retargetReq = new RetargetCaretRequest(
                 (EditPart) oldTextPieceKeeper, e.keyCode, e.character,
                 acceptableText(e.character), p, caretOffset);
         ITextPieceKeeper nextTextPieceKeeper = (ITextPieceKeeper) ((EditPart) oldTextPieceKeeper)
                 .getTargetEditPart(retargetReq);
 
         if (nextTextPieceKeeper == null)
             throw new IllegalStateException("Cannot move to null EditPart"); //$NON-NLS-1$
 
         if (oldTextPieceKeeper != nextTextPieceKeeper)
             setPartUnderCaret((EditPart) nextTextPieceKeeper);
 
         textRequest.setDestination(nextTextPieceKeeper);
 
         sendRequest((EditPart) oldTextPieceKeeper, textRequest);
     }
 
     protected void performDelete(KeyEvent e) {
         if (getPartUnderCaret() == null)
             return;
 
         int length = 0;
         if (e.character == SWT.BS)
             length = -1;
         if (e.keyCode == 127)
             length = 1;
         DeleteTextRequest deleteRequest = new DeleteTextRequest(
                 (ITextPieceKeeper) getPartUnderCaret(), this.caretManager
                         .getCaretOffset(), length);
 
         /*
          * request.setAction(EditTextRequest.DELETE);
          * 
          * EditPart target = getActive().getTargetEditPart(request);
          * 
          * if (target == null) return;
          */
         TextEditPart oldEditPart = (TextEditPart) getPartUnderCaret();
         Point p = new Point(this.caretManager.getLocation().x, oldEditPart
                 .getTextLocator().getTextBounds().y);
 
         int caretOffset = this.caretManager.getCaretOffset();
         RetargetCaretRequest retargetReq = new RetargetCaretRequest(
                 oldEditPart, e.keyCode, e.character,
                 acceptableText(e.character), p, caretOffset);
         EditPart nextEditPart = oldEditPart.getTargetEditPart(retargetReq);
 
         if (nextEditPart == null)
             throw new IllegalStateException("Cannot move to null EditPart"); //$NON-NLS-1$
 
         if (oldEditPart != nextEditPart)
             setPartUnderCaret(nextEditPart);
 
         deleteRequest.setDestination((ITextPieceKeeper) nextEditPart);
         sendRequest(getPartUnderCaret(), deleteRequest);
     }
 
 
     /***
      * @param e
      * @return
      */
     protected boolean acceptableArrow(KeyEvent e) {
         int code = e.keyCode;
         return (code == SWT.ARROW_LEFT) || (code == SWT.ARROW_RIGHT)
                 || (code == SWT.ARROW_DOWN) || (code == SWT.ARROW_UP)
                 || (code == SWT.HOME) || (code == SWT.END);
     }
 
     /***
      * @param e
      * @return
      */
     protected boolean isDeletingAction(KeyEvent e) {
         return (e.keyCode == SWT.BS) || (e.keyCode == SWT.DEL);
     }
 
     @Override
     protected boolean handleKeyDown(KeyEvent e) {
         if (!((getCurrentInput().isShiftKeyDown() || e.keyCode == SWT.CONTROL) || (getCurrentInput()
                 .isControlKeyDown() || e.keyCode == SWT.SHIFT))) {
             getCurrentViewer().deselectAll();
         }
 
         if ((e.keyCode == SWT.SHIFT) || (getCurrentInput().isShiftKeyDown()))
         {
         	performInitSelection();
         }
 
         if (isWaitForRepaint()) {
             this.eventBuffer.add(e);
             return super.handleKeyDown(e);
         }
 
         if (acceptableArrow(e)) {
             performArrowMove(e);
             if (getCurrentInput().isShiftKeyDown())
             	performDragingSelection();
 
         } else if (acceptableText(e.character)) {
             // TODO Kollar: delete selected text and input new text
             // setCaretMovement(1);
             performTextInput(e);
             // setWaitForRepaint(true);
         } else if (isDeletingAction(e)) {
             // TODO Kollar: delete selected text
             // setCaretMovement(0);
             performDelete(e);
             // setWaitForRepaint(true);
         }
 
         // return super.handleKeyDown(e);
         return true;
     }
 
     @Override
     protected boolean handleKeyUp(KeyEvent e) {
         if ( (e.keyCode == SWT.ESC) && (getCurrentInput().isShiftKeyDown()) ){
         	//while selecting ESC is pressed - this cause discarding current selection
             clearSelection();
         	DOMIntervalSet globalSelection = ((IXMLGraphicalViewer)getCurrentViewer()).getDOMSelection();
         	((IXMLGraphicalViewer)getCurrentViewer()).setSelection(globalSelection);
         }
         
         // 166 = t/T
         if ((e.keyCode == 116) && (getCurrentInput().isControlKeyDown())) {
             this.caretManager.deactivateCaret();
             getDomain().setActiveTool(
                     new TextStructureTool(((TextEditPart) getPartUnderCaret())
                             .getTextLocator().getTextBounds().getBottomLeft(),
                             getPartUnderCaret()));
         }
         
         if (e.keyCode == SWT.SHIFT) {
         	performFinishSelection();
         }
 
         return super.handleKeyUp(e);
     }
 
     /***
      * @param target
      * @param request
      */
     protected void sendRequest(EditPart target, Request request) {
         assert (target != null);
         target.performRequest(request);
     }
 
     @Override
     protected boolean handleButtonDown(int button) {
     	clearSelection();
         return super.handleButtonDown(button);        
     }
 
     /***
      * Switchs the tool to StructureTool if the structure element was clicked or
      * performs MouseClick
      * 
      * @param button
      *            that is released
      * @return <code>true</code> if the button up was handled
      */
     @Override
     protected boolean handleButtonUp(int button) {
         return super.handleButtonUp(button);
     }
 
     protected void performInitSelection(){
     	this.localSelection = new DOMInterval(
     			this.caretManager.getDOMPointer(),this.caretManager.getDOMPointer());
     }
     
     /***
      * Puts together(makes union) globalSelction with localSelction and updates
      * this new globalSelection to GraphicalViewer 
      */
     protected void performDragingSelection(){
     	DomPointer from = this.localSelection.from;
     	DomPointer to = this.caretManager.getDOMPointer();
     	this.localSelection = new DOMInterval(from,to);
     	DOMIntervalSet globalSelection = ((IXMLGraphicalViewer)getCurrentViewer()).getDOMSelection();
     	globalSelection.union(this.localSelection);
     	//TODO: Kollar DOMIntervalSet.union returns set difference between
     	// globalSelection and localSelection, it is DOMIntervalSet - set of DOMIntervals
     	// that if will be add to old globalSelection, that this will make the same
     	// new globalSelection. This can be used to define the change between old selection and
     	// new selection. Only this change should be then updated in SelectionPolicy for instance.
     	((IXMLGraphicalViewer)getCurrentViewer()).showSelection(globalSelection);
     }
     
     protected void performFinishSelection(){
     	DOMIntervalSet globalSelection = ((IXMLGraphicalViewer)getCurrentViewer()).getDOMSelection();
     	globalSelection.union(this.localSelection);
     	((IXMLGraphicalViewer)getCurrentViewer()).setSelection(globalSelection);
     	clearSelection();
     }
     
     protected void clearSelection(){
     	this.localSelection = null;
     }
     
     /***
      * @param keepers
      * @param nodeIndex
      * @return
      */
     protected int findLine(List<ITextPieceKeeper> keepers, final int nodeIndex) {
         int result = 0;
         int endIndex;
         for (ITextPieceKeeper keeper : keepers) {
             endIndex = keeper.getTextPieceInfo().getOffset()
                     + keeper.getTextPieceInfo().getLength();
             if (endIndex < nodeIndex)
                 result++;
             else
                 break;
         }
         return Math.min(result, keepers.size() - 1);
     }
 
     /***
      * Method to corect state of this tool after transformation of document.
      * That means to set correctly caret exactly to the position in document
      * where was before transformation and handle after caret events.
      * 
      * @param map
      */
     public void reinit(Map<String, TextPieceContainer> map) {
         // do some corrective steps
     }
 
     /***
      * @return
      */
     private boolean isWaitForRepaint() {
         return this.waitForRepaint;
     }
 
     /***
      * @param waitForRepaint
      */
     private void setWaitForRepaint(boolean waitForRepaint) {
         this.waitForRepaint = waitForRepaint;
     }
 
     /***
      * @return EditPart under Caret
      */
     public EditPart getPartUnderCaret() {
         return this.partUnderCaret;
     }
 
     /***
      * @param part
      *            EditPart that is now active
      */
     public void setPartUnderCaret(EditPart part) {
         this.partUnderCaret = part;
     }
 
 
 
 }