package processing.mode.java;

import static processing.mode.java.ASTUtils.findAllOccurrences;

import static processing.mode.java.ASTUtils.getSimpleNameAt;

import static processing.mode.java.ASTUtils.resolveBinding;

import java.awt.Dimension;

import java.awt.EventQueue;

import java.awt.event.ComponentAdapter;

import java.awt.event.ComponentEvent;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

import javax.swing.Box;

import javax.swing.JButton;

import javax.swing.JDialog;

import javax.swing.JLabel;

import javax.swing.JMenuItem;

import javax.swing.JOptionPane;

import javax.swing.JRootPane;

import javax.swing.JTextField;

import javax.swing.WindowConstants;

import javax.swing.border.EmptyBorder;

import javax.swing.text.BadLocationException;

import org.eclipse.jdt.core.dom.ASTNode;

import org.eclipse.jdt.core.dom.CompilationUnit;

import org.eclipse.jdt.core.dom.IBinding;

import org.eclipse.jdt.core.dom.IMethodBinding;

import org.eclipse.jdt.core.dom.ITypeBinding;

import org.eclipse.jdt.core.dom.SimpleName;

import processing.app.Language;

import processing.app.Platform;

import processing.app.Sketch;

import processing.app.SketchCode;

import processing.app.syntax.SyntaxDocument;

import processing.app.ui.EditorStatus;

import processing.app.ui.Toolkit;

class Rename {

final JavaEditor editor;

final PreprocService pps;

final ShowUsage showUsage;

final JDialog window;

final JTextField textField;

final JLabel oldNameLabel;

IBinding binding;

PreprocSketch ps;

Rename(JavaEditor editor, PreprocService pps, ShowUsage showUsage) {

this.editor = editor;

this.pps = pps;

this.showUsage = showUsage;

// Add rename option

JMenuItem renameItem = new JMenuItem(Language.text("editor.popup.rename"));

renameItem.addActionListener(e -> handleRename());

editor.getTextArea().getRightClickPopup().add(renameItem);

window = new JDialog(editor);

JRootPane rootPane = window.getRootPane();

window.setTitle("Rename");

window.setDefaultCloseOperation(WindowConstants.HIDE_ON_CLOSE);

Toolkit.registerWindowCloseKeys(rootPane, e -> window.setVisible(false));

Toolkit.setIcon(window);

window.setModal(true);

window.setResizable(false);

window.addComponentListener(new ComponentAdapter() {

@Override

public void componentHidden(ComponentEvent e) {

binding = null;

ps = null;

}

});

Box windowBox = Box.createVerticalBox();

windowBox.setBorder(new EmptyBorder(20, 20, 20, 20));

final int GAP = Toolkit.zoom(5);

{ // old name

Box oldBox = Box.createHorizontalBox();

oldNameLabel = new JLabel("Current Name: ");

oldBox.add(oldNameLabel);

//oldBox.add(Box.createHorizontalStrut(10));

oldBox.add(Box.createHorizontalGlue());

windowBox.add(oldBox);

windowBox.add(Box.createVerticalStrut(GAP));

}

{ // new name

Box newBox = Box.createHorizontalBox();

JLabel newNameLabel = new JLabel("New Name: ");

newBox.add(newNameLabel);

newBox.add(textField = new JTextField(20));

newBox.add(Box.createHorizontalGlue());

windowBox.add(newBox);

windowBox.add(Box.createVerticalStrut(GAP*2));

}

{ // button panel

JButton showUsageButton = new JButton("Show Usage");

showUsageButton.addActionListener(e -> {

showUsage.findUsageAndUpdateTree(ps, binding);

window.setVisible(false);

});

JButton renameButton = new JButton("Rename");

renameButton.addActionListener(e -> {

final String newName = textField.getText().trim();

if (!newName.isEmpty()) {

if (newName.chars().limit(1).allMatch(Character::isJavaIdentifierStart) &&

newName.chars().skip(1).allMatch(Character::isJavaIdentifierPart)) {

rename(ps, binding, newName);

window.setVisible(false);

} else {

String msg = String.format("'%s' is not a valid name", newName);

JOptionPane.showMessageDialog(editor, msg, "Naming is Hard",

JOptionPane.PLAIN_MESSAGE);

}

}

});

rootPane.setDefaultButton(renameButton);

Box buttonBox = Box.createHorizontalBox();

buttonBox.add(Box.createHorizontalGlue());

buttonBox.add(showUsageButton);

if (!Platform.isMacOS()) {

buttonBox.add(Box.createHorizontalStrut(GAP));

}

buttonBox.add(renameButton);

buttonBox.add(Box.createHorizontalGlue());

Dimension showDim = showUsageButton.getPreferredSize();

Dimension renameDim = renameButton.getPreferredSize();

final int niceSize = Math.max(showDim.width, renameDim.width) + GAP;

final Dimension buttonDim = new Dimension(niceSize, showDim.height);

showUsageButton.setPreferredSize(buttonDim);

renameButton.setPreferredSize(buttonDim);

windowBox.add(buttonBox);

//window.add(panelBottom);

}

window.add(windowBox);

window.pack();

//window.setMinimumSize(window.getSize());

}

// Thread: EDT

void handleRename() {

int startOffset = editor.getSelectionStart();

int stopOffset = editor.getSelectionStop();

int tabIndex = editor.getSketch().getCurrentCodeIndex();

pps.whenDoneBlocking(ps -> handleRename(ps, tabIndex, startOffset, stopOffset));

}

// Thread: worker

void handleRename(PreprocSketch ps, int tabIndex, int startTabOffset, int stopTabOffset) {

if (ps.hasSyntaxErrors) {

editor.statusMessage("Cannot rename until syntax errors are fixed",

EditorStatus.WARNING);

return;

}

ASTNode root = ps.compilationUnit;

// Map offsets

int startJavaOffset = ps.tabOffsetToJavaOffset(tabIndex, startTabOffset);

int stopJavaOffset = ps.tabOffsetToJavaOffset(tabIndex, stopTabOffset);

// Find the node

SimpleName name = getSimpleNameAt(root, startJavaOffset, stopJavaOffset);

if (name == null) {

editor.statusMessage("Highlight the class/function/variable name first",

EditorStatus.NOTICE);

return;

}

// Find binding

IBinding binding = resolveBinding(name);

if (binding == null) {

editor.statusMessage(name.getIdentifier() + " isn't defined in this sketch, " +

"so it cannot be renamed", EditorStatus.ERROR);

return;

}

ASTNode decl = ps.compilationUnit.findDeclaringNode(binding.getKey());

if (decl == null) {

editor.statusMessage(name.getIdentifier() + " isn't defined in this sketch, " +

"so it cannot be renamed", EditorStatus.ERROR);

return;

}

// Display the rename dialog

EventQueue.invokeLater(() -> {

if (!window.isVisible()) {

this.ps = ps;

this.binding = binding;

oldNameLabel.setText("Current name: " + binding.getName());

textField.setText(binding.getName());

textField.requestFocus();

textField.selectAll();

int x = editor.getX() + (editor.getWidth() - window.getWidth()) / 2;

int y = editor.getY() + (editor.getHeight() - window.getHeight()) / 2;

window.setLocation(x, y);

window.setVisible(true);

window.toFront();

}

});

}

// Thread: EDT (we can't allow user to mess with sketch while renaming)

void rename(PreprocSketch ps, IBinding binding, String newName) {

CompilationUnit root = ps.compilationUnit;

// Renaming constructor should rename class

if (binding.getKind() == IBinding.METHOD) {

IMethodBinding method = (IMethodBinding) binding;

if (method.isConstructor()) {

binding = method.getDeclaringClass();

}

}

ASTNode decl = root.findDeclaringNode(binding.getKey());

if (decl == null) return;

showUsage.hide();

List<SimpleName> occurrences =

new ArrayList<>(findAllOccurrences(root, binding.getKey()));

// Renaming class should rename all constructors

if (binding.getKind() == IBinding.TYPE) {

ITypeBinding type = (ITypeBinding) binding;

//type = type.getErasure();

IMethodBinding[] methods = type.getDeclaredMethods();

Arrays.stream(methods)

.filter(IMethodBinding::isConstructor)

.flatMap(c -> findAllOccurrences(root, c.getKey()).stream())

.forEach(occurrences::add);

}

Map<Integer, List<SketchInterval>> mappedNodes = occurrences.stream()

.map(ps::mapJavaToSketch)

.filter(ps::inRange)

.collect(Collectors.groupingBy(interval -> interval.tabIndex));

Sketch sketch = ps.sketch;

editor.startCompoundEdit();

mappedNodes.forEach((key, nodes) -> {

int tabIndex = key;

SketchCode sketchCode = sketch.getCode(tabIndex);

SyntaxDocument document = (SyntaxDocument) sketchCode.getDocument();

nodes.stream()

// Replace from the end so all unprocessed offsets stay valid

.sorted(Comparator.comparing((SketchInterval si) -> si.startTabOffset).reversed())

.forEach(si -> {

// Make sure offsets are in bounds

int documentLength = document.getLength();

if (si.startTabOffset >= 0 && si.startTabOffset <= documentLength &&

si.stopTabOffset >= 0 && si.stopTabOffset <= documentLength) {

// Replace the code

int length = si.stopTabOffset - si.startTabOffset;

try {

document.remove(si.startTabOffset, length);

document.insertString(si.startTabOffset, newName, null);

} catch (BadLocationException e) { /* Whatever */ }

}

});

try {

sketchCode.setProgram(document.getText(0, document.getLength()));

} catch (BadLocationException e) { /* Whatever */ }

sketchCode.setModified(true);

});

editor.stopCompoundEdit();

editor.repaintHeader();

int currentTabIndex = sketch.getCurrentCodeIndex();

final int currentOffset = editor.getCaretOffset();

int precedingIntervals =

(int) mappedNodes.getOrDefault(currentTabIndex, Collections.emptyList())

.stream()

.filter(interval -> interval.stopTabOffset < currentOffset)

.count();

int intervalLengthDiff = newName.length() - binding.getName().length();

int offsetDiff = precedingIntervals * intervalLengthDiff;

editor.getTextArea().setCaretPosition(currentOffset + offsetDiff);

}

void dispose() {

if (window != null) {

window.dispose();

}

}

}