package nodebox.client;

import edu.umd.cs.piccolo.PNode;

import edu.umd.cs.piccolo.event.PBasicInputEventHandler;

import edu.umd.cs.piccolo.event.PInputEvent;

import edu.umd.cs.piccolo.util.PPaintContext;

import nodebox.node.ConnectionError;

import nodebox.node.InvalidNameException;

import nodebox.node.Node;

import nodebox.node.Port;

import javax.imageio.ImageIO;

import javax.swing.*;

import javax.swing.border.Border;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.KeyEvent;

import java.awt.event.MouseEvent;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.io.File;

import java.io.IOException;

import static nodebox.base.Preconditions.checkNotNull;

public class NodeView extends PNode implements Selectable, PropertyChangeListener {

public static final int NODE_FULL_SIZE = 70;

public static final int NODE_IMAGE_SIZE = 50;

public static final int TEXT_HEIGHT = 14;

public static final int NODE_OUTPUT_DRAG_ZONE = 15;

public static final Rectangle OUTPUT_BOUNDS = new Rectangle(NODE_FULL_SIZE - NODE_OUTPUT_DRAG_ZONE, (NODE_FULL_SIZE - NODE_OUTPUT_DRAG_ZONE - 6) / 2, NODE_OUTPUT_DRAG_ZONE, NODE_OUTPUT_DRAG_ZONE + 6);

public static final int NODE_PORT_HEIGHT = 10;

private static final int NODE_PORT_MARGIN = 5;

public static final int GRID_SIZE = 10;

private static BufferedImage nodeMask, nodeGlow, nodeConnectionGlow, nodeInPort, nodeOutPort, nodeGeneric, nodeError, nodeRendered, nodeCodeChanged, nodeRim;

static {

try {

nodeMask = ImageIO.read(new File("res/node-mask.png"));

nodeGlow = ImageIO.read(new File("res/node-glow.png"));

nodeConnectionGlow = ImageIO.read(new File("res/node-connection-glow.png"));

nodeInPort = ImageIO.read(new File("res/node-in-port.png"));

nodeOutPort = ImageIO.read(new File("res/node-out-port.png"));

nodeGeneric = ImageIO.read(new File("res/node-generic.png"));

nodeError = ImageIO.read(new File("res/node-error.png"));

nodeRendered = ImageIO.read(new File("res/node-rendered.png"));

nodeCodeChanged = ImageIO.read(new File("res/node-codechanged.png"));

nodeRim = ImageIO.read(new File("res/node-rim.png"));

} catch (IOException e) {

e.printStackTrace();

}

}

private NetworkView networkView;

private Node node;

private BufferedImage fullIcon;

private Border border;

private boolean selected;

private transient boolean codeChanged;

private transient double fakeX, fakeY;

public NodeView(NetworkView networkView, Node node) {

this.networkView = networkView;

this.node = node;

this.selected = false;

this.codeChanged = false;

setTransparency(1.0F);

addInputEventListener(new NodeHandler());

setOffset(node.getX(), node.getY());

setBounds(0, 0, NODE_FULL_SIZE, NODE_FULL_SIZE + TEXT_HEIGHT);

addPropertyChangeListener(PROPERTY_TRANSFORM, this);

addPropertyChangeListener(PROPERTY_BOUNDS, this);

addInputEventListener(new PopupHandler());

updateIcon();

}

public NodeBoxDocument getDocument() {

return networkView.getDocument();

}

/**

* Tries to find an image representation for the node.

* The image should be located near the library, and have the same name as the library.

* <p/>

* If this node has no image, the prototype is searched to find its image. If no image could be found,

* a generic image is retured.

*

* @param node the node

* @return an Image object.

*/

public static BufferedImage getImageForNode(Node node) {

if (node == null || node.getImage() == null || node.getImage().equals(Node.IMAGE_GENERIC)) return nodeGeneric;

File libraryFile = node.getLibrary().getFile();

if (libraryFile != null) {

File libraryDirectory = libraryFile.getParentFile();

if (libraryDirectory != null) {

File nodeImageFile = new File(libraryDirectory, node.getImage());

if (nodeImageFile.exists()) {

try {

return ImageIO.read(nodeImageFile);

} catch (IOException ignored) {

// Pass through

}

}

}

}

// Look for the prototype

return getImageForNode(node.getPrototype());

}

/**

* Calculate the vertical offset for the port. This value starts from the full node size.

*

* @param port the port. The index of the port is used to calculate the offset.

* @return the vertical offset

*/

public static int getVerticalOffsetForPort(Port port) {

Node node = port.getNode();

java.util.List<Port> ports = node.getPorts();

int portIndex = node.getPorts().indexOf(port);

int portCount = ports.size();

int totalPortsHeight = (NODE_PORT_HEIGHT + NODE_PORT_MARGIN) * (portCount - 1) + NODE_PORT_HEIGHT;

int offsetPerPort = NODE_PORT_HEIGHT + NODE_PORT_MARGIN;

int portStartY = (NODE_FULL_SIZE - totalPortsHeight) / 2 - 1;

return portStartY + portIndex * offsetPerPort;

}

/**

* Create an icon with the node's image and the rounded embellishments.

*

* @param node the node

* @return an Image object.

*/

public static BufferedImage getFullImageForNode(Node node, boolean drawPorts) {

Image icon = getImageForNode(node);

// Create the icon.

// We include only the parts that are not changed by state.

// This means leaving off the error and rendered image.

// Also, we draw the rim at the very end, above the error and rendered,

// so we can't draw it here yet.

BufferedImage fullIcon = new BufferedImage(NODE_FULL_SIZE, NODE_FULL_SIZE, BufferedImage.TYPE_INT_ARGB);

Graphics2D fg = fullIcon.createGraphics();

if (drawPorts) {

// Count the input ports and draw them.

java.util.List<Port> inputs = node.getPorts();

for (Port p : inputs) {

int portY = getVerticalOffsetForPort(p);

fg.drawImage(nodeInPort, 0, portY, null);

}

fg.drawImage(nodeOutPort, 0, 0, null);

}

// Draw the other layers.

fg.drawImage(nodeMask, 0, 0, null);

fg.setComposite(AlphaComposite.SrcIn);

fg.drawImage(icon, 10, 10, NODE_IMAGE_SIZE, NODE_IMAGE_SIZE, null);

fg.setComposite(AlphaComposite.SrcOver);

//fg.drawImage(nodeReflection, 0, 0, null);

fg.dispose();

return fullIcon;

}

public void updateIcon() {

fullIcon = getFullImageForNode(node, true);

}

public void propertyChange(PropertyChangeEvent evt) {

if (evt.getPropertyName().equals(PROPERTY_TRANSFORM)) {

getDocument().setNodePosition(node, new nodebox.graphics.Point(super.getOffset()));

}

}

public NetworkView getNetworkView() {

return networkView;

}

public Node getNode() {

return node;

}

public Border getBorder() {

return border;

}

public void setBorder(Border border) {

this.border = border;

}

protected void paint(PPaintContext ctx) {

Graphics2D g = ctx.getGraphics();

Shape clip = g.getClip();

g.clip(getBounds());

g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

g.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);

// Draw the selection/connection border

if (selected && networkView.getConnectionTarget() != this)

g.drawImage(nodeGlow, 0, 0, null);

if (networkView.getConnectionTarget() == this)

g.drawImage(nodeConnectionGlow, 0, 0, null);

g.drawImage(fullIcon, 0, 0, null);

if (codeChanged)

g.drawImage(nodeCodeChanged, 0, 0, null);

if (node.hasError())

g.drawImage(nodeError, 0, 0, null);

if (node.isRendered())

g.drawImage(nodeRendered, 0, 0, null);

g.drawImage(nodeRim, 0, 0, null);

// Draw the node name.

g.setFont(Theme.SMALL_BOLD_FONT);

g.setColor(Theme.NETWORK_NODE_NAME_COLOR);

int textWidth = g.getFontMetrics().stringWidth(node.getName());

int x = (int) ((NODE_FULL_SIZE - textWidth) / 2f);

SwingUtils.drawShadowText(g, node.getName(), x, NODE_FULL_SIZE + 5, Theme.NETWORK_NODE_NAME_SHADOW_COLOR, -1);

// Reset the clipping.

g.setClip(clip);

}

public boolean isSelected() {

return selected;

}

public void setSelected(boolean s) {

if (selected == s) return;

selected = s;

repaint();

}

public boolean hasCodeChanged() {

return codeChanged;

}

public void setCodeChanged(boolean changed) {

if (codeChanged == changed) return;

codeChanged = changed;

repaint();

}

private void doRename() {

String s = JOptionPane.showInputDialog(networkView, "New name:", node.getName());

if (s == null || s.length() == 0)

return;

try {

getDocument().setNodeName(node, s);

} catch (InvalidNameException ex) {

JOptionPane.showMessageDialog(networkView, "The given name is not valid.\n" + ex.getMessage(), Application.NAME, JOptionPane.ERROR_MESSAGE);

}

}

@Override

public Point2D getOffset() {

return new Point2D.Double(fakeX, fakeY);

}

@Override

public void setOffset(Point2D pt) {

setOffset(pt.getX(), pt.getY());

}

@Override

public void setOffset(double x, double y) {

fakeX = x;

fakeY = y;

super.setOffset(snap(fakeX), snap(fakeY));

}

private static double snap(double value) {

value = Math.round(value);

return Math.round(value / GRID_SIZE) * GRID_SIZE;

}

private class NodeHandler extends PBasicInputEventHandler {

protected Point2D dragPoint;

private boolean isDragging;

public void mouseClicked(PInputEvent e) {

if (e.getClickCount() == 1) {

e.getInputManager().setKeyboardFocus(this);

networkView.singleSelect(NodeView.this);

} else if (e.getClickCount() == 2 && e.isLeftMouseButton()) {

Point2D pt = NodeView.this.getOffset();

double y = e.getPosition().getY() - pt.getY();

// Check if we're clicking on the label, which is below the node.

// We give the user some space below to compensate for the glow.

if (y > NODE_FULL_SIZE - 4) {

doRename();

} else {

getDocument().setRenderedNode(node);

}

}

e.setHandled(true);

}

public void mousePressed(PInputEvent e) {

if (isPanningEvent(e)) return;

if (e.getButton() == MouseEvent.BUTTON1) {

Point2D pt = NodeView.this.getOffset();

double x = e.getPosition().getX() - pt.getX();

double y = e.getPosition().getY() - pt.getY();

// Find the area where the mouse is pressed

// Possible areas are the output connector and the node itself.

if (OUTPUT_BOUNDS.contains(x, y)) {

isDragging = false;

networkView.startConnection(NodeView.this);

} else {

isDragging = true;

dragPoint = e.getPosition();

// Make sure that this node is also selected.

if (!isSelected()) {

// If other nodes are selected, deselect them so they

// don't get dragged along.

networkView.singleSelect(NodeView.this);

}

}

}

}

public void mouseEntered(PInputEvent e) {

if (networkView.isConnecting() && networkView.getConnectionSource() != NodeView.this) {

networkView.setTemporaryConnectionTarget(NodeView.this);

}

}

public void mouseExited(PInputEvent e) {

if (networkView.isConnecting()) {

networkView.setTemporaryConnectionTarget(null);

}

}

public void mouseDragged(PInputEvent e) {

if (isPanningEvent(e)) return;

if (isDragging) {

checkNotNull(dragPoint, "dragPoint cannot be null.");

Point2D pt = e.getPosition();

double dx = pt.getX() - dragPoint.getX();

double dy = pt.getY() - dragPoint.getY();

getNetworkView().dragSelection(dx, dy);

dragPoint = pt;

} else if (networkView.isConnecting()) {

Point2D p = e.getPosition();

networkView.dragConnectionPoint(p);

}

e.setHandled(true);

}

public void mouseReleased(PInputEvent event) {

if (networkView.isConnecting()) {

// Check if both source and target are set.

if (networkView.getConnectionSource() != null && networkView.getConnectionTarget() != null) {

Node source = networkView.getConnectionSource().getNode();

Node target = networkView.getConnectionTarget().getNode();

// Look for compatible ports.

java.util.List<Port> compatiblePorts = target.getCompatibleInputs(source);

if (compatiblePorts.isEmpty()) {

// There are no compatible parameters.

} else if (compatiblePorts.size() == 1) {

// Only one possible connection, make it now.

Port inputPort = compatiblePorts.get(0);

try {

getDocument().connect(source.getOutputPort(), inputPort);

} catch (ConnectionError e) {

JOptionPane.showMessageDialog(networkView, e.getMessage(), "Connection error", JOptionPane.ERROR_MESSAGE);

}

} else {

JPopupMenu menu = new JPopupMenu("Select input");

for (Port p : compatiblePorts) {

Action a = new SelectCompatiblePortAction(source, p);

menu.add(a);

}

Point pt = getNetworkView().getMousePosition();

menu.show(getNetworkView(), pt.x, pt.y);

}

}

networkView.endConnection();

}

}

private boolean isPanningEvent(PInputEvent event) {

return (event.getModifiers() & MouseEvent.ALT_MASK) != 0;

}

}

class SelectCompatiblePortAction extends AbstractAction {

private Node outputNode;

private Port inputPort;

SelectCompatiblePortAction(Node outputNode, Port inputPort) {

super(inputPort.getName());

this.outputNode = outputNode;

this.inputPort = inputPort;

}

public void actionPerformed(ActionEvent e) {

try {

getDocument().connect(outputNode.getOutputPort(), inputPort);

} catch (ConnectionError ce) {

JOptionPane.showMessageDialog(networkView, ce.getMessage(), "Connection error", JOptionPane.ERROR_MESSAGE);

}

}

}

private class PopupHandler extends PBasicInputEventHandler {

public void processEvent(PInputEvent e, int i) {

if (!e.isPopupTrigger()) return;

JPopupMenu menu = new JPopupMenu();

menu.add(new SetRenderedAction());

menu.add(new RenameAction());

menu.add(new DeleteAction());

menu.add(new GoInAction());

Point2D p = e.getCanvasPosition();

menu.show(NodeView.this.networkView, (int) p.getX(), (int) p.getY());

e.setHandled(true);

}

}

private class SetRenderedAction extends AbstractAction {

private SetRenderedAction() {

super("Set Rendered");

}

public void actionPerformed(ActionEvent e) {

getDocument().setRenderedNode(node);

networkView.repaint();

}

}

private class RenameAction extends AbstractAction {

private RenameAction() {

super("Rename");

}

public void actionPerformed(ActionEvent e) {

doRename();

}

}

private class DeleteAction extends AbstractAction {

public DeleteAction() {

super("Delete");

putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_BACK_SPACE, 0));

}

public void actionPerformed(ActionEvent e) {

getDocument().removeNode(node);

}

}

private class GoInAction extends AbstractAction {

private GoInAction() {

super("Edit Children");

putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0));

}

public void actionPerformed(ActionEvent e) {

getDocument().setActiveNetwork(node);

}

}

}