package com.framsticks.gui;

import com.framsticks.core.*;
import com.framsticks.params.annotations.AutoAppendAnnotation;
import com.framsticks.params.annotations.FramsClassAnnotation;
import com.framsticks.params.annotations.ParamAnnotation;
import com.framsticks.util.Logging;
import com.framsticks.util.dispatching.AbstractJoinable;
import com.framsticks.util.dispatching.Dispatcher;
import com.framsticks.util.dispatching.Dispatching;
import com.framsticks.util.dispatching.Future;
import com.framsticks.util.dispatching.Joinable;
import com.framsticks.util.dispatching.JoinableCollection;
import com.framsticks.util.dispatching.JoinableParent;
import com.framsticks.util.dispatching.JoinableState;

import javax.swing.*;

import org.apache.log4j.Logger;

import java.awt.Dimension;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import com.framsticks.util.dispatching.RunAt;

/**
 * @author Piotr Sniegowski
 */
@FramsClassAnnotation
public class Browser extends AbstractJoinable implements Dispatcher<Browser>, Entity, JoinableParent {

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

	protected JoinableCollection<Frame> frames = new JoinableCollection<Frame>().setObservableName("frames");
	protected JoinableCollection<Instance> instances = new JoinableCollection<Instance>().setObservableName("instances");

	protected MainFrame mainFrame;
	public List<PanelProvider> panelProviders = new ArrayList<PanelProvider>();
	protected Dimension defaultFrameDimension;

	String name;

	public void addFrame(Frame frame) {
		frames.add(frame);
	}

	public Browser() {
		setName("browser");
		JPopupMenu.setDefaultLightWeightPopupEnabled(false);
		addPanelProvider(new StandardPanelProvider());

		mainFrame = new MainFrame(Browser.this);
		addFrame(mainFrame);
	}

	@AutoAppendAnnotation
	public void addPanelProvider(PanelProvider panelProvider) {
		log.debug("added panel provider of type: " + panelProvider.getClass().getCanonicalName());
		panelProviders.add(panelProvider);
	}

	@AutoAppendAnnotation
	public void addInstance(Instance instance) {
		log.info("adding instance: " + instance);
		instances.add(instance);
	}

	public void autoResolvePath(final String path, final Future<Path> future) {
		final Instance i = instances.get("localhost");
		i.invokeLater(new RunAt<Instance>() {
			@Override
			public void run() {
				i.resolveAndFetch(path, new Future<Path>() {
					@Override
					public void result(final Path p, Exception e) {
						Logging.log(log, "auto resolve path", path, e);
						if (future != null) {
							future.result(p, e);
						}
						if (e == null) {
							mainFrame.invokeLater(new RunAt<Frame>() {
								@Override
								public void run() {
									mainFrame.goTo(p);
								}
							});
						}
					}
				});
			}
		});
	}

	public void clear() {
		assert isActive();
		for (Frame f : frames) {
			f.clear();
		}
	}

	protected void firstTask() {
		assert isActive();
		log.info("executing first task");

		try {
			boolean found = false;
			// for (LookAndFeelInfo info : UIManager.getInstalledLookAndFeels()) {
			//	log.info("look and feel available: " + info.getName());
			//	if ("Nimbus".equals(info.getName())) {
			//		UIManager.setLookAndFeel(info.getClassName());
			//		found = true;
			//		break;
			//	}
			// }
			if (!found) {
				UIManager.setLookAndFeel("com.sun.java.swing.plaf.gtk.GTKLookAndFeel");
			}
		} catch (Exception ex) {
			log.warn("failed loading Look&Feel: ", ex);
		}

		javax.swing.JFrame.setDefaultLookAndFeelDecorated(true);


		for (Frame f : frames) {
			f.configure();
		}

		for (final Instance i : instances) {
			i.invokeLater(new RunAt<Instance>() {
				@Override
				public void run() {
					final Path p = i.getRootPath();
					invokeLater(new RunAt<Browser>() {
						@Override
						public void run() {
							mainFrame.addRootPath(p);
						}
					});
				}
			});
		}

		for (Frame f : frames) {
			f.getSwing().setVisible(true);
		}

		// autoResolvePath("/simulator/genepools/groups/0", null);
		// autoResolvePath("/", null);
	}

	public void createTreeNodeForChild(final Path path) {
		assert !isActive();
		//assert instance.isActive();

		/*
		 final TreeNode parentTreeNode = (TreeNode) child.getParent().getUserObject();
		 if (parentTreeNode == null) {
		 Dispatching.invokeDispatch(this, manager, new Runnable() {
		 @Override
		 public void run() {
		 createTreeNodeForChild(child);
		 }
		 });
		 return;
		 }
		 log.debug(child.getClass().getSimpleName() + " created: " + child);


		 invokeLater(new Runnable() {
		 @Override
		 public void run() {
		 parentTreeNode.getOrCreateChildTreeNodeFor(child);
		 }
		 });
		 */
	}

	@Override
	protected void joinableStart() {
		Dispatching.use(frames, this);
		Dispatching.use(instances, this);

		invokeLater(new RunAt<Browser>() {
			@Override
			public void run() {
				firstTask();
			}
		});
	}

	/**
	 * @return the instances
	 */
	public Map<String, Instance> getInstances() {
		return instances.getObservables();
	}

	/**
	 * @return the mainFrame
	 */
	public MainFrame getMainFrame() {
		return mainFrame;
	}

	/**
	 * @return the name
	 */
	@ParamAnnotation
	public String getName() {
		return name;
	}

	/**
	 * @param name the name to set
	 */
	@ParamAnnotation
	public void setName(String name) {
		this.name = name;
	}

	@Override
	public boolean isActive() {
		return SwingDispatcher.getInstance().isActive();
	}

	@Override
	public void invokeLater(RunAt<? extends Browser> runnable) {
		SwingDispatcher.getInstance().invokeLater(runnable);
	}

	@Override
	protected void joinableJoin() throws InterruptedException {
		Dispatching.join(frames);
		Dispatching.join(instances);
		// super.join();
	}

	@Override
	protected void joinableInterrupt() {
		Dispatching.drop(frames, this);
		Dispatching.drop(instances, this);
	}

	@Override
	public void childChangedState(Joinable joinable, JoinableState state) {
		if (joinable == frames) {
			proceedToState(state);
		}

	}

	@Override
	protected void joinableFinish() {
		// TODO Auto-generated method stub

	}

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


	// @Override
	// public boolean isDone() {
	//	return frames.isDone() && instances.isDone();
	// }
}