package nodebox.client;

import nodebox.client.editor.SimpleEditor;

import nodebox.node.Node;

import nodebox.node.Parameter;

import nodebox.node.ProcessingContext;

import javax.swing.*;

import javax.swing.border.Border;

import javax.swing.event.CaretEvent;

import javax.swing.event.CaretListener;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

import javax.swing.text.Element;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.PrintWriter;

import java.io.StringWriter;

import java.util.Map;

import java.util.WeakHashMap;

import static nodebox.base.Preconditions.checkNotNull;

public class EditorPane extends Pane implements CaretListener, ChangeListener, ActionListener {

private final Map<Parameter, String> inProgressCode = new WeakHashMap<Parameter, String>();

private final NodeBoxDocument document;

private Node activeNode;

private Parameter activeParameter;

private String codeType = "_code";

private PaneHeader paneHeader;

private SimpleEditor editor;

private EditorSplitPane splitter;

private JTextArea messages;

private NButton messagesCheck;

private NButton reloadButton;

private boolean ignoringChanges = true;

public EditorPane(NodeBoxDocument document) {

this.document = document;

setLayout(new BorderLayout(0, 0));

paneHeader = new PaneHeader(this);

reloadButton = new NButton("Reload", "res/code-reload.png");

setReloadButtonEnabled(false); // Only enable the button if the code has changed.

reloadButton.setActionMethod(this, "reload");

messagesCheck = new NButton(NButton.Mode.CHECK, "Messages");

messagesCheck.setActionMethod(this, "toggleMessages");

paneHeader.add(reloadButton);

paneHeader.add(new Divider());

paneHeader.add(messagesCheck);

paneHeader.add(new Divider());

PaneCodeMenu paneCodeMenu = new PaneCodeMenu();

paneCodeMenu.addActionListener(this);

paneHeader.add(paneCodeMenu);

editor = new SimpleEditor();

editor.addCaretListener(this);

editor.addChangeListener(this);

add(paneHeader, BorderLayout.NORTH);

messages = new JTextArea();

messages.setEditable(false);

messages.setBorder(new TopLineBorder());

messages.setFont(Theme.EDITOR_FONT);

messages.setMargin(new Insets(0, 5, 0, 5));

JScrollPane messagesScroll = new JScrollPane(messages, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);

messagesScroll.setBorder(BorderFactory.createEmptyBorder());

splitter = new EditorSplitPane(JSplitPane.VERTICAL_SPLIT, editor, messagesScroll);

add(splitter, BorderLayout.CENTER);

}

public Pane duplicate() {

return new EditorPane(document);

}

public String getPaneName() {

return "Source";

}

public PaneHeader getPaneHeader() {

return paneHeader;

}

public PaneView getPaneView() {

return editor;

}

public void setActiveNode(Node node) {

activeNode = node;

if (activeNode != null) {

activeParameter = getCodeParameter(activeNode, codeType);

} else {

activeParameter = null;

}

updateSource();

}

public void setCodeType(String codeType) {

this.codeType = codeType;

activeParameter = getCodeParameter(activeNode, codeType);

updateSource();

paneHeader.repaint();

clearMessages();

}

private void updateSource() {

if (activeParameter != null) {

if (hasInProgressCode(activeParameter)) {

setSource(getInProgressCode(activeParameter));

setReloadButtonEnabled(true);

} else {

Parameter codeParameter = activeNode.getParameter(codeType);

setSource(codeParameter.asCode().getSource());

setReloadButtonEnabled(false);

}

} else {

setSource(null);

setReloadButtonEnabled(false);

}

}

public void reload() {

// This method can be called from the menu bar, so we need to check if the code has really changed.

if (!hasInProgressCode(activeParameter)) return;

document.setActiveNodeCode(activeParameter, getSource());

removeInProgressCode(activeParameter);

// The code has been set so there is nothing to reload.

setReloadButtonEnabled(false);

}

private void setReloadButtonEnabled(boolean v) {

reloadButton.setEnabled(v);

reloadButton.setWarning(v);

}

public String getSource() {

return editor.getSource();

}

public boolean isIgnoringChanges() {

return ignoringChanges;

}

public void setIgnoringChanges(boolean ignoringChanges) {

this.ignoringChanges = ignoringChanges;

}

public void setSource(String source) {

// Setting the source will trigger change events for every line of source code.

// Ignore changes temporarily, and re-enable when the source has been set.

setIgnoringChanges(true);

if (source == null) {

editor.setSource("");

editor.setEnabled(false);

messages.setEnabled(false);

messages.setBackground(Theme.MESSAGES_BACKGROUND_COLOR);

splitter.setShowMessages(false);

} else {

editor.setSource(source);

editor.setEnabled(true);

messages.setEnabled(true);

messages.setBackground(Color.white);

// The source has been set. All subsequent changes are triggered by the user.

setIgnoringChanges(false);

}

}

public void toggleMessages() {

setShowMessages(messagesCheck.isChecked());

}

private void setShowMessages(boolean v) {

splitter.setShowMessages(v);

messagesCheck.setChecked(v);

}

/**

* Set the messages to a given string.

* This is used for exceptions in the handle code.

*

* @param s The string to display.

*/

public void setMessages(String s) {

if (s != null && !s.isEmpty()) {

messages.setText(s);

setShowMessages(true);

// Ensure messages are visible.

splitter.setShowMessages(true);

} else {

messages.setText("");

}

}

/**

* Clear out the text in messages.

*/

public void clearMessages() {

setMessages("");

}

/**

* Update the messages after the node has done processing.

* <p/>

* This is only used for _code, not for _handles.

*

* @param node The node that was processed.

* @param context The node's processing context.

*/

public void updateMessages(Node node, ProcessingContext context) {

// If we're looking at the handle don't show messages for the node.

if (codeType.equals("_handle")) return;

StringBuilder sb = new StringBuilder();

if (node != null) {

// Add the error messages.

if (node.hasError()) {

StringWriter sw = new StringWriter();

Throwable t = node.getError();

t.printStackTrace(new PrintWriter(sw));

sb.append(t.toString());

//sb.append(t.getMessage()).append("\n");

Throwable cause = t.getCause();

while (cause != null) {

sb.append("Caused by: \n");

sb.append(cause.toString()).append("\n");

// Sometimes the cause is stored recursively.

// Break out of the loop instead of triggering infinite recursion.

if (cause.getCause() == cause) {

break;

}

cause = cause.getCause();

}

}

// Add the stdout messages.

if (context != null && context.getOutput().length() > 0) {

sb.append(context.getOutput());

}

}

if (sb.length() > 0) {

messages.setText(sb.toString());

setShowMessages(true);

// Ensure messages are visible

splitter.setShowMessages(true);

} else {

messages.setText("");

}

}

public void caretUpdate(CaretEvent e) {

JEditorPane editArea = (JEditorPane) e.getSource();

int caretPosition = editArea.getCaretPosition();

Element root = editArea.getDocument().getDefaultRootElement();

int line = root.getElementIndex(caretPosition) + 1;

// Subtract the offset of the start of the line from the caret position.

// Add one because line numbers are zero-based.

int column = 1 + caretPosition - root.getElement(line - 1).getStartOffset();

updatePosition(line, column);

}

private void updatePosition(int line, int column) {

splitter.setLocation(line, column);

}

/**

* This method gets called by the editor component if the source has changed.

*

* @param changeEvent The type of change.

*/

public void stateChanged(ChangeEvent changeEvent) {

// The editor also triggers state changes when using setSource(). We ignore those changes.

if (isIgnoringChanges()) return;

setInProgressCode(activeParameter, getSource());

setReloadButtonEnabled(true);

document.codeEdited(getSource());

}

//// In-progress code ////

private Parameter getCodeParameter(Node node, String codeType) {

checkNotNull(node, "Trying to get a code parameter for a null node.");

Parameter p = node.getParameter(codeType);

checkNotNull(p, "Parameter %s on node %s could not be found.", codeType, node);

return p;

}

private void setInProgressCode(Parameter p, String source) {

inProgressCode.put(p, source);

}

private String getInProgressCode(Parameter p) {

return inProgressCode.get(p);

}

private void removeInProgressCode(Parameter p) {

inProgressCode.remove(p);

}

private boolean hasInProgressCode(Parameter p) {

return inProgressCode.containsKey(p);

}

public void actionPerformed(ActionEvent e) {

// We know the event will always come from the pane code type menu.

setCodeType(e.getActionCommand());

}

private class TopLineBorder implements Border {

public void paintBorder(Component component, Graphics g, int x, int y, int width, int height) {

g.setColor(Theme.DEFAULT_SPLIT_COLOR);

g.drawLine(x, y, x + width, y);

}

public Insets getBorderInsets(Component component) {

return new Insets(1, 0, 0, 0);

}

public boolean isBorderOpaque() {

return true;

}

}

}