package nodebox.node;

import java.lang.ref.WeakReference;
import java.util.Collection;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * The NodeAccessProxy makes access to nodes and parameters more
 * convenient from expressions. So, instead of writing:
 * <p/>
 * <pre><code>network.getNode("rect1").getParameter("x").getValue()</code></pre>
 * <p/>
 * You can write:
 * <p/>
 * <pre><code>network.rect1.x</code></pre>
 * <p/>
 * The network and node classes in this example are proxies; they look up
 * the node in the nodes dictionary for the network, and return another
 * proxy object.
 */
public class NodeAccessProxy implements Map {

    private Node node;
    private Set<String> keySet;
    private Set<WeakReference<Parameter>> markedParameterReferences;

    public NodeAccessProxy(Node node) {
        this.node = node;
        updateKeys();
    }

    /**
     * Initialize the proxy with a access marker that notes which parameters were accessed.
     * This marker will be passed to recursive proxies.
     *
     * @param node                      the node
     * @param markedParameterReferences a list of parameters that were marked.
     */
    public NodeAccessProxy(Node node, Set<WeakReference<Parameter>> markedParameterReferences) {
        this(node);
        this.markedParameterReferences = markedParameterReferences;
    }

    private void updateKeys() {
        keySet = new HashSet<String>();
        // keySet is created in reverse order; from global to local scope.
        // 1. Add nodes
        // 1.1 Add names of the sibling nodes (nodes in the same network as this node.)
        if (node.hasParent()) {
            for (Node n : node.getParent().getChildren()) {
                keySet.add(n.getName());
            }
        }
        // 1.2 Add its child nodes.
        for (Node n : node.getChildren()) {
            keySet.add(n.getName());
        }
        // 2. Add parameters
        for (Parameter p : node.getParameters()) {
            keySet.add(p.getName());
        }
        // 3. Add reserved words
        keySet.add("root");
        keySet.add("parent");
    }

    public Node getNode() {
        return node;
    }

    public int size() {
        return keySet.size();
    }

    public boolean isEmpty() {
        return false;
    }

    public boolean containsKey(Object key) {
        if (key == null) return false;
        if (!(key instanceof String)) return false;
        return keySet.contains((String) key);
    }

    public boolean containsValue(Object value) {
        throw new RuntimeException("Not implemented");
    }

    /**
     * Retrieve the node or parameter value from the proxy.
     * Value retrieval happens in a specific order, from local to global:
     * <ul>
     * <li>Search for reserved words (network, root).</li>
     * <li>Search for the name in the parameters of the current node.</li>
     * <li>If this node is a network, search in the nodes of the current network. (children)</li>
     * <li>If this node is in a network, search for other nodes in that network. (siblings)</li>
     * </ul>
     *
     * @param key the key to search for
     * @return a Parameter value or a NodeProxy object.
     */
    public Object get(Object key) {
        if (key == null) return null;
        String k = key.toString();

        // First search for reserved words.
        if (k.equals("node")) {
            return node;
        } else if (k.equals("parent")) {
            if (node.hasParent()) {
                return new NodeAccessProxy(node.getParent(), markedParameterReferences);
            } else {
                return null;
            }
        } else if (k.equals("root")) {
            if (node.hasParent()) {
                return new NodeAccessProxy(node.getParent(), markedParameterReferences);
            } else {
                // If the node does not have a parent, I am my own root node.
                return this;
            }
        }

        // Search the parameters
        if (node.hasParameter(k)) {
            if (markedParameterReferences != null)
                markedParameterReferences.add(new WeakReference<Parameter>(node.getParameter(k)));
            return node.getValue(k);
        }

        // Network searches
        // If this is a network, search its nodes first.
        if (node.contains(k)) {
            return new NodeAccessProxy(node.getChild(k), markedParameterReferences);
        }

        // Check the siblings (nodes in this node's network).
        if (node.hasParent() && node.getParent().contains(k)) {
            return new NodeAccessProxy(node.getParent().getChild(k), markedParameterReferences);
        }

        // Don't know what to return.
        return null;
    }

    public Object put(Object key, Object value) {
        throw new AssertionError("You cannot change the node access proxy.");
    }

    public Object remove(Object key) {
        throw new AssertionError("You cannot change the node access proxy.");
    }

    public void putAll(Map t) {
        throw new AssertionError("You cannot change the node access proxy.");
    }

    public void clear() {
        throw new AssertionError("You cannot change the node access proxy.");
    }

    public Set keySet() {
        return keySet;
    }

    public Collection values() {
        throw new RuntimeException("Not implemented");
    }

    public Set entrySet() {
        throw new RuntimeException("Not implemented");
    }

    @Override
    public String toString() {
        if (node == null) {
            return "<Empty proxy>";
        } else {
            return "<Node " + node.getName() + ">";
        }
    }
}