package com.framsticks.gui;

import org.apache.log4j.Logger;

import com.framsticks.core.Instance;
import com.framsticks.core.InstanceListener;
import com.framsticks.core.ListChange;
import com.framsticks.core.Node;
import com.framsticks.core.Path;
import com.framsticks.params.CompositeParam;
import com.framsticks.params.FramsClass;

import java.util.*;

import javax.swing.tree.TreePath;
import com.framsticks.util.dispatching.RunAt;

/**
 * @author Piotr Sniegowski
 */
public class InstanceAtFrame implements InstanceListener {

	private static final Logger log = Logger.getLogger(InstanceAtFrame.class);

	protected final Frame frame;
	protected final Instance instance;
	protected final Map<String, Panel> knownPanels = new HashMap<String, Panel>();
	protected TreeNode rootTreeNode;

	public InstanceAtFrame(Instance instance, Frame frame) {
		this.frame = frame;
		this.instance = instance;
	}

	public Frame getFrame() {
		return frame;
	}

	/**
	 * @return the instance
	 */
	public Instance getInstance() {
		return instance;
	}

	public void registerPanel(Panel panel) {
	}

	public Panel findPanel(String accessId) {
		assert frame.isActive();
		return (knownPanels.containsKey(accessId) ? knownPanels.get(accessId) : null);
	}

	public final String getName() {
		return instance.getName();
	}

	public Panel preparePanel(CompositeParam param, FramsClass framsClass) {
		assert frame.isActive();
		Panel panel = preparePanelImpl(param, framsClass);
		assert panel != null;
		String accessId = param.computeAccessId();
		panel.uniqueName = accessId + "@" + instance.getName();
		knownPanels.put(accessId, panel);
		frame.cardPanel.add(panel, panel.uniqueName);
		log.debug("prepared panel for " + panel);
		return panel;
	}

	protected Panel preparePanelImpl(CompositeParam param, FramsClass framsClass) {
		assert frame.isActive();
		List<Panel> panels = new ArrayList<Panel>();

		Panel.Parameters parameters = new Panel.Parameters(this, param, framsClass);
		for (PanelProvider pp : frame.browser.panelProviders) {
			Panel p = pp.providePanel(parameters);
			if (p != null) {
				panels.add(p);
			}
		}

		if (panels.isEmpty()) {
			return new EmptyPanel(parameters);
		}
		if (panels.size() == 1) {
			return panels.get(0);
		}
		return new MultiPanel(parameters, panels);

	}

	@Override
	public void onListChange(Path path, ListChange change) {

	}

	public TreePath getTreePath(Path path, boolean create) {
		assert frame.isActive();
		TreeNode t = rootTreeNode;
		TreePath result = new TreePath(frame.rootNode).pathByAddingChild(rootTreeNode);
		List<Node> nodes = path.getNodes();
		Iterator<Node> i = nodes.iterator();
		i.next();
		// Node first = i.next();

		// if (!t.path.isResolved()) {
		//	t.path = new Path(path.getInstance(), nodes, first);
		// }
		while (i.hasNext()) {
			Node n = i.next();
			TreeNode r = null;
			for (TreeNode c : t.childrenIterable()) {
				if (c.paramId.equals(n.getParam().getId())) {
					r = c;
					break;
				}
			}
			if (r == null) {
				log.debug("missing " + n.getParam().getId() + " in " + t);
				if (!create) {
					return result;
				}
				Path p = Path.build().instance(path.getInstance()).buildUpTo(nodes, n).finish();


				log.debug("forced resolution: creating treenode for " + p);
				TreeNode childNode = new TreeNode(InstanceAtFrame.this, p);

				frame.addNode(childNode, t);
				// frame.treeModel.reload();
				// t.add(childNode);
				// frame.treeModel.nodeStructureChanged(t);

				r = childNode;
			} else {
				// if (!r.path.isResolved()) {
				//	r.path = new Path(path.getInstance(), nodes, n);
				// }
			}
			result = result.pathByAddingChild(r);
			t = r;
		}
		return result;
	}

	@Override
	public void onFetch(final Path path) {
		assert instance.isActive();
		log.trace("fetched " + path);

		frame.dispatch(new RunAt<Frame>() {
			@Override
			public void run() {

				TreePath treePath = getTreePath(path, true);
				assert treePath.getPathCount() == path.size() + 1;

				final TreeNode result = (TreeNode) treePath.getLastPathComponent();
				// log.trace("found " + result + " == " + path);
				instance.dispatch(new RunAt<Instance>() {
					@Override
					public void run() {
						result.reactForFetchResult(path, null);
					}
				});
			}
		});
	}

	@Override
	public void onRun(Exception e) {

	}

	@Override
	public void onStop(Exception e) {

	}
}