package nodebox.node;

import nodebox.node.event.*;
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.*;

/**
 * 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 enum ExternalEvent {FRAME, CANVAS}

    public static final NodeLibrary BUILTINS = new NodeLibrary();

    public static final String CANVAS_X = "canvasX";
    public static final String CANVAS_Y = "canvasY";
    public static final String CANVAS_WIDTH = "canvasWidth";
    public static final String CANVAS_HEIGHT = "canvasHeight";
    public static final String CANVAS_BACKGROUND = "canvasBackground";
    public static final float DEFAULT_CANVAS_WIDTH = 1000f;
    public static final float DEFAULT_CANVAS_HEIGHT = 1000f;
    // TODO: If the background color can be changed somewhere, all libraries are changed.
    public static final nodebox.graphics.Color DEFAULT_CANVAS_BACKGROUND = new nodebox.graphics.Color(1);

    private String name;
    private File file;
    private Node rootNode;
    private float frame = 1F;
    private HashMap<String, String> variables;
    private NodeCode code;
    private NodeEventBus eventBus = new NodeEventBus();
    private CanvasListener canvasListener = new CanvasListener();

    private DependencyGraph<Parameter, Object> parameterGraph = new DependencyGraph<Parameter, Object>();
    private Map<ExternalEvent, HashSet<Parameter>> externalDependencies = new HashMap<ExternalEvent, HashSet<Parameter>>();

    /**
     * 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 " + libraryName + ": " + 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 " + f + ": " + 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);
        setCanvasParameter(library, CANVAS_X);
        setCanvasParameter(library, CANVAS_Y);
        setCanvasParameter(library, CANVAS_WIDTH);
        setCanvasParameter(library, CANVAS_HEIGHT);
        setCanvasParameter(library, CANVAS_BACKGROUND);
    }

    private static void setCanvasParameter(NodeLibrary library, String name) {
        String valueAsString = library.getVariable(name);
        Parameter param = library.getRootNode().getParameter(name);
        if (param != null && valueAsString != null)
            param.set(param.parseValue(valueAsString));
    }

    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 LinkedHashMap<String, String>();
        Parameter pCanvasBackground = rootNode.addParameter(CANVAS_BACKGROUND, Parameter.Type.COLOR, DEFAULT_CANVAS_BACKGROUND);
        Parameter pCanvasWidth = rootNode.addParameter(CANVAS_WIDTH, Parameter.Type.FLOAT, DEFAULT_CANVAS_WIDTH);
        Parameter pCanvasHeight = rootNode.addParameter(CANVAS_HEIGHT, Parameter.Type.FLOAT, DEFAULT_CANVAS_HEIGHT);
        Parameter pCanvasX = rootNode.addParameter(CANVAS_X, Parameter.Type.FLOAT, 0f);
        Parameter pCanvasY = rootNode.addParameter(CANVAS_Y, Parameter.Type.FLOAT, 0f);
        pCanvasBackground.setLabel("Background Color");
        pCanvasWidth.setLabel("Document Width");
        pCanvasHeight.setLabel("Document Height");
        pCanvasX.setLabel("Offset X");
        pCanvasY.setLabel("Offset Y");
        this.rootNode.setValue("_code", new WrapInCanvasCode());
        // We listen to our own library for changes to canvas settings.
        // The listener object needs to be stored in a field, otherwise it will get garbage-collected.
        // The event bus only stores weak references.
        addListener(canvasListener);
    }

    public String getName() {
        return name;
    }

    public File getFile() {
        return file;
    }

    public void setFile(File file) {
        if (this.file != null) {
            throw new AssertionError("File can only be set if no file was set before.");
        }
        this.file = 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);
    }

    /**
     * Get the node at the given absolute path.
     * This method does a best effort to get the most specific node. If it fails to find a given segment,
     * it stops and returns the parent.
     *
     * @param path the path to parse
     * @return a node somewhere within the path, hopefully at the end.
     * @see nodebox.node.Node#getAbsolutePath()
     */
    public Node getNodeForPath(String path) {
        Node parent = getRootNode();
        if (!path.startsWith("/")) return parent;
        for (String part : path.substring(1).split("/")) {
            Node child = parent.getChild(part);
            if (child == null) {
                break;
            } else {
                parent = child;
            }
        }
        return parent;
    }

    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.containsChildNode(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;
    }

    //// Animation ////

    public float getFrame() {
        return frame;
    }

    public void setFrame(float frame) {
        this.frame = frame;
        externalDependencyTriggered(ExternalEvent.FRAME);
    }

    //// 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 {
        file = f;
        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);
    }

    //// External event dependencies ////

    /**
     * Indicates that Parameter p depends on an external event, such as a change to the frame or canvas size.
     * This method is called whenever an expression is set that refers to e.g. FRAME.
     * <p/>
     * Whenever this external event happens, the parameter will be marked dirty.
     *
     * @param p     the parameter
     * @param event the event
     */
    public void addExternalDependency(Parameter p, ExternalEvent event) {
        HashSet<Parameter> parameters = externalDependencies.get(event);
        if (parameters == null) {
            parameters = new HashSet<Parameter>();
            externalDependencies.put(event, parameters);
        }
        parameters.add(p);
    }

    /**
     * Removes all external dependencies for Parameter p.
     * This happens when an expression is cleared.
     *
     * @param p the parameter.
     */
    public void removeExternalDependencies(Parameter p) {
        for (HashSet<Parameter> parameters : externalDependencies.values()) {
            for (Iterator<Parameter> iterator = parameters.iterator(); iterator.hasNext(); ) {
                Parameter parameter = iterator.next();
                if (parameter == p) {
                    iterator.remove();
                }
            }
        }
    }

    /**
     * This method is called when an external event, such as a frame change, happened.
     * <p/>
     * All the parameters that depend on this event will be marked dirty.
     *
     * @param event the event that was triggered
     */
    public void externalDependencyTriggered(ExternalEvent event) {
        HashSet<Parameter> parameters = externalDependencies.get(event);
        if (parameters != null) {
            for (Parameter p : parameters) {
                p.markDirty();
            }
        }
    }

    //// Events ////

    public void addListener(NodeEventListener l) {
        eventBus.addListener(l);
    }

    public boolean removeListener(NodeEventListener l) {
        return eventBus.removeListener(l);
    }

    public List<NodeEventListener> getListeners() {
        return eventBus.getListeners();
    }

    public void fireNodeDirty(Node source) {
        eventBus.send(new NodeDirtyEvent(source));
    }

    public void fireNodeUpdated(Node source, ProcessingContext context) {
        eventBus.send(new NodeUpdatedEvent(source, context));
    }

    public void fireNodeAttributeChanged(Node source, Node.Attribute attribute) {
        eventBus.send(new NodeAttributeChangedEvent(source, attribute));
    }

    public void fireChildAdded(Node source, Node child) {
        eventBus.send(new ChildAddedEvent(source, child));
    }

    public void fireChildRemoved(Node source, Node child) {
        eventBus.send(new ChildRemovedEvent(source, child));
    }

    public void fireConnectionAdded(Node source, Connection c) {
        eventBus.send(new ConnectionAddedEvent(source, c));
    }

    public void fireConnectionRemoved(Node source, Connection c) {
        eventBus.send(new ConnectionRemovedEvent(source, c));
    }

    public void fireRenderedChildChanged(Node source, Node child) {
        eventBus.send(new RenderedChildChangedEvent(source, child));
    }

    public void fireValueChanged(Node source, Parameter parameter) {
        eventBus.send(new ValueChangedEvent(source, parameter));
    }

    //// Standard overrides ////

    @Override
    public String toString() {
        return getName();
    }

    /**
     * Custom listener that listens to changes in canvas properties and triggers an external event change.
     */
    private class CanvasListener implements NodeEventListener {
        public void receive(NodeEvent event) {
            if (event.getSource() != getRootNode()) return;
            if (!(event instanceof ValueChangedEvent)) return;
            ValueChangedEvent vce = (ValueChangedEvent) event;
            if (!vce.getParameter().getName().startsWith("canvas")) return;
            externalDependencyTriggered(ExternalEvent.CANVAS);
        }
    }
}