package nodebox.node;

import nodebox.util.FileUtils;

import org.xml.sax.SAXException;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

import java.io.*;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Set;

/**

* A Node library stores a set of (possibly hierarchical) nodes.

* <p/>

* Node libraries are both documents and libraries. By mentioning a node on the library search path, you can get

* all the nodes.

* <p/>

* Node libraries can be backed by files, and saved in that same file, or they can be stored in memory only.

* <p/>

* This implementation of the node library only stores a root node.

* Calling get(String) on the library actually forwards the call to getChild() on the root node.

*/

public class NodeLibrary {

public static final NodeLibrary BUILTINS = new NodeLibrary();

private String name;

private File file;

private Node rootNode;

private HashMap<String, String> variables;

private NodeCode code;

private DependencyGraph<Parameter, Object> parameterGraph = new DependencyGraph<Parameter, Object>();

/**

* Load a library from the given XML.

* <p/>

* This library is not added to the manager. The manager is used only to look up prototypes.

* You can add the library to the manager yourself using manager.add(), or by calling

* manager.load().

*

* @param libraryName the name of the new library

* @param xml the xml data of the library

* @param manager the manager used to look up node prototypes.

* @return a new node library

* @throws RuntimeException When the string could not be parsed.

* @see nodebox.node.NodeLibraryManager#add(NodeLibrary)

* @see nodebox.node.NodeLibraryManager#load(String, String)

*/

public static NodeLibrary load(String libraryName, String xml, NodeLibraryManager manager) throws RuntimeException {

try {

NodeLibrary library = new NodeLibrary(libraryName);

load(library, new ByteArrayInputStream(xml.getBytes("UTF8")), manager);

return library;

} catch (ParserConfigurationException e) {

throw new RuntimeException("Error in the XML parser configuration", e);

} catch (SAXException e) {

throw new RuntimeException("Error while parsing: " + e.getMessage(), e);

} catch (IOException e) {

throw new RuntimeException("I/O error while parsing.", e);

}

}

/**

* Load a library from the given file.

* <p/>

* This library is not added to the manager. The manager is used only to look up prototypes.

* You can add the library to the manager yourself using manager.add(), or by calling

* manager.load().

*

* @param f the file to load

* @param manager the manager used to look up node prototypes.

* @return a new node library

* @throws RuntimeException When the file could not be found, or parsing failed.

* @see nodebox.node.NodeLibraryManager#add(NodeLibrary)

* @see nodebox.node.NodeLibraryManager#load(File)

*/

public static NodeLibrary load(File f, NodeLibraryManager manager) throws RuntimeException {

try {

// The library name is the file name without the ".ndbx" extension.

// Chop off the .ndbx

String libraryName = FileUtils.stripExtension(f);

NodeLibrary library = new NodeLibrary(libraryName, f);

load(library, new FileInputStream(f), manager);

return library;

} catch (ParserConfigurationException e) {

throw new RuntimeException("Error in the XML parser configuration", e);

} catch (SAXException e) {

throw new RuntimeException("Error while parsing: " + e.getMessage(), e);

} catch (FileNotFoundException e) {

throw new RuntimeException("File not found " + f, e);

} catch (IOException e) {

throw new RuntimeException("I/O error while parsing " + f, e);

}

}

/**

* This method gets called from the public load method and does the actual parsing.

* <p/>

* The method requires a newly created (empty) library. Nodes are added to this library.

*

* @param library the newly created library

* @param is the input stream data

* @param manager the manager used for looking up prototypes.

* @throws IOException when the data could not be loaded

* @throws ParserConfigurationException when the parser is incorrectly configured

* @throws SAXException when the data could not be parsed

*/

private static void load(NodeLibrary library, InputStream is, NodeLibraryManager manager) throws IOException, ParserConfigurationException, SAXException {

SAXParserFactory spf = SAXParserFactory.newInstance();

SAXParser parser = spf.newSAXParser();

NDBXHandler handler = new NDBXHandler(library, manager);

parser.parse(is, handler);

}

private NodeLibrary() {

this.name = "builtins";

this.file = null;

this.rootNode = null;

this.variables = null;

}

public NodeLibrary(String name) {

this(name, null);

}

public NodeLibrary(String name, File file) {

this.name = name;

this.file = file;

this.rootNode = Node.ROOT_NODE.newInstance(this, "root");

this.variables = new HashMap<String, String>();

}

public String getName() {

return name;

}

public File getFile() {

return file;

}

//// Node management ////

public Node getRootNode() {

return rootNode;

}

public List<Node> getExportedNodes() {

List<Node> allChildren = rootNode.getChildren();

List<Node> exportedChildren = new ArrayList<Node>(allChildren.size());

for (Node child : allChildren) {

if (child.isExported()) {

exportedChildren.add(child);

}

}

return exportedChildren;

}

public void add(Node node) {

if (node.getLibrary() != this) throw new AssertionError("This node is already added to another library.");

// The root node can be null in only one case: when we're creating the builtins library.

// In that case, the rootNode becomes the given node.

if (rootNode == null) {

rootNode = node;

} else {

rootNode.add(node);

}

}

/**

* Get a node from this library.

* <p/>

* Only exported nodes are returned. If you want all nodes, use getRootNode().getChild()

*

* @param name the name of the node

* @return the node, or null if a node with this name could not be found.

*/

public Node get(String name) {

if ("root".equals(name)) return rootNode;

return rootNode.getExportedChild(name);

}

public Node remove(String name) {

Node node = rootNode.getChild(name);

if (node == null) return null;

rootNode.remove(node);

return node;

}

public boolean remove(Node node) {

return rootNode.remove(node);

}

public int size() {

return rootNode.size();

}

public boolean contains(String nodeName) {

return rootNode.contains(nodeName);

}

//// Variables ////

public String[] getVariableNames() {

return variables.keySet().toArray(new String[variables.keySet().size()]);

}

public String getVariable(String name) {

return variables.get(name);

}

public void setVariable(String name, String value) {

variables.put(name, value);

}

//// Code ////

public void setCode(NodeCode code) {

this.code = code;

}

public NodeCode getCode() {

return code;

}

//// Persistence /////

public void store() throws IOException, IllegalArgumentException {

if (file == null)

throw new IllegalArgumentException("Library was not loaded from a file and no file given to store.");

store(file);

}

public void store(File f) throws IOException {

NDBXWriter.write(this, f);

}

/**

* Get the full XML data for this library and all of its nodes.

*

* @return an XML string

*/

public String toXml() {

return NDBXWriter.asString(this);

}

//// Parameter dependencies ////

/**

* Add a dependency between two parameters.

* <p/>

* Whenever the dependent node wants to update, it needs to check if the dependency

* is clean. Also, whenever the dependency changes, the dependent gets notified.

* <p/>

* Do not call this method directly. Instead, let Parameter create the dependencies by using setExpression().

*

* @param dependency the parameter that provides the value

* @param dependent the parameter that needs the value

* @see nodebox.node.Parameter#setExpression(String)

*/

public void addParameterDependency(Parameter dependency, Parameter dependent) {

parameterGraph.addDependency(dependency, dependent);

}

/**

* Remove all dependencies this parameter has.

* <p/>

* This method gets called when a parameter clears out its expression.

* <p/>

* Do not call this method directly. Instead, let Parameter remove dependencies by using clearExpression().

*

* @param p the parameter

* @see nodebox.node.Parameter#clearExpression()

*/

public void removeParameterDependencies(Parameter p) {

parameterGraph.removeDependencies(p);

}

/**

* Remove all dependents this parameter has.

* <p/>

* This method gets called when the parameter is about to be removed. It signal all of its dependent nodes

* that the parameter will no longer be available.

* <p/>

* Do not call this method directly. Instead, let Parameter remove dependents by using removeParameter().

*

* @param p the parameter

* @see Node#removeParameter(String)

*/

public void removeParameterDependents(Parameter p) {

parameterGraph.removeDependents(p);

}

/**

* Get all parameters that rely on this parameter.

* <p/>

* These parameters all have expressions that point to this parameter. Whenever this parameter changes,

* they get notified.

* <p/>

* This list contains all "live" parameters when you call it. Please don't hold on to this list for too long,

* since parameters can be added and removed at will.

*

* @param p the parameter

* @return a list of parameters that depend on this parameter. This list can safely be modified.

*/

public Set<Parameter> getParameterDependents(Parameter p) {

return parameterGraph.getDependents(p);

}

/**

* Get all parameters this parameter depends on.

* <p/>

* This list contains all "live" parameters when you call it. Please don't hold on to this list for too long,

* since parameters can be added and removed at will.

*

* @param p the parameter

* @return a list of parameters this parameter depends on. This list can safely be modified.

*/

public Set<Parameter> getParameterDependencies(Parameter p) {

return parameterGraph.getDependencies(p);

}

//// Standard overrides ////

@Override

public String toString() {

return getName();

}

}