/*
 * Copyright 2003-2011 JetBrains s.r.o.
 *
 * 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 jetbrains.mps.nodeEditor.cellActions;

import jetbrains.mps.editor.runtime.cells.AbstractCellAction;
import jetbrains.mps.editor.runtime.cells.ReadOnlyUtil;
import jetbrains.mps.editor.runtime.impl.CellUtil;
import jetbrains.mps.lang.smodel.generator.smodelAdapter.AttributeOperations;
import jetbrains.mps.openapi.editor.EditorComponent;
import jetbrains.mps.openapi.editor.EditorContext;
import jetbrains.mps.openapi.editor.cells.EditorCell;
import jetbrains.mps.openapi.editor.selection.SelectionManager;
import org.jetbrains.mps.openapi.language.SContainmentLink;
import org.jetbrains.mps.openapi.model.SNode;

import java.util.Iterator;

/**
 * Author: Sergey Dmitriev.
 * Time: Nov 5, 2003 1:03:02 PM
 */
public class CellAction_DeleteNode extends AbstractCellAction {
  private final SNode mySemanticNode;
  private final DeleteDirection myDirection;

  public CellAction_DeleteNode(SNode semanticNode) {
    this(semanticNode, DeleteDirection.FORWARD);
  }

  public CellAction_DeleteNode(SNode semanticNode, DeleteDirection direction) {
    mySemanticNode = semanticNode;
    myDirection = direction;
  }

  protected SNode getSourceNode() {
    return mySemanticNode;
  }

  @Override
  public boolean canExecute(EditorContext context) {
    final SNode nodeToDelete = getNodeToDelete(context);
    if (nodeToDelete == null || nodeToDelete.getParent() == null) {
      return false;
    }
    EditorCell cell = context.getEditorComponent().findNodeCell(mySemanticNode);
    return cell != null && cell.getParent() != null && !ReadOnlyUtil.isCellOrSelectionReadOnlyInEditor(context.getEditorComponent(), cell);
  }

  @Override
  public void execute(EditorContext context) {
    SNode nodeToDelete = getNodeToDelete(context);
    SNode parent = nodeToDelete.getParent();
    SContainmentLink containmentLink;
    if (AttributeOperations.isChildAttribute(nodeToDelete)){
      containmentLink = AttributeOperations.getChildLink(nodeToDelete);
    } else {
      containmentLink = nodeToDelete.getContainmentLink();
    }
    boolean isForward = myDirection == DeleteDirection.FORWARD;

    boolean selectStart = isForward;
    SNode siblingToSelect = getSiblingToSelect(parent, nodeToDelete, isForward, containmentLink);

    if (siblingToSelect == null) {
      selectStart = !isForward;
      siblingToSelect = getSiblingToSelect(parent, nodeToDelete, !isForward, containmentLink);
    }
    nodeToDelete.delete();
    context.flushEvents();
    setSelection(context.getEditorComponent(), parent, siblingToSelect, selectStart, containmentLink);
  }

  protected SNode getNodeToDelete(EditorContext context) {
    return CellUtil.getNodeToDelete(mySemanticNode);
  }

  private SNode getSiblingToSelect(SNode parent, SNode node, boolean isNext, SContainmentLink containmentLink) {
    Iterator<? extends SNode> iterator = AttributeOperations.getChildNodesAndAttributes(parent, containmentLink).iterator();
    SNode prev = null;
    while (iterator.hasNext()) {
      SNode child = iterator.next();
      if (child == node) {
        if (isNext) {
          return iterator.hasNext() ? iterator.next() : null;
        } else {
          return prev;
        }
      }
      prev = child;
    }
    return null;
  }

  private void setSelection(EditorComponent editorComponent, SNode parent, SNode siblingToSelect, boolean isStartPosition, SContainmentLink link) {
    if (siblingToSelect != null) {
      selectNode(editorComponent, siblingToSelect, isStartPosition);
    } else {
      selectNullCell(editorComponent, parent, link);
    }
  }

  private boolean selectNode(EditorComponent editorComponent, SNode node, boolean isStartPosition) {
    if (isStartPosition) {
      editorComponent.getSelectionManager().setSelection(node, SelectionManager.FIRST_CELL, 0);
    } else {
      editorComponent.getSelectionManager().setSelection(node, SelectionManager.LAST_CELL, -1);
    }
    return true;
  }


  private void selectNullCell(EditorComponent editorComponent, SNode parent, SContainmentLink link) {
    EditorCell nullCell = editorComponent.findNodeCellWithRole(parent, link.getName());
    if (nullCell != null) {
      ((jetbrains.mps.nodeEditor.EditorComponent) editorComponent).changeSelectionWRTFocusPolicy(nullCell);
      return;
    }
    selectNode(editorComponent, parent, false);
  }

  public enum DeleteDirection {
    FORWARD,
    BACKWARD
  }
}
