package com.framsticks.remote;

import java.util.List;

import org.apache.log4j.Logger;

import static com.framsticks.core.TreeOperations.*;
import com.framsticks.communication.EventCallback;
import com.framsticks.communication.File;
import com.framsticks.communication.util.LoggingSubscriptionCallback;
import com.framsticks.core.Tree;
import com.framsticks.core.TreeOperations;
import com.framsticks.core.Path;
import com.framsticks.params.annotations.FramsClassAnnotation;
import com.framsticks.params.types.EventParam;
import com.framsticks.util.Logging;
import com.framsticks.util.PeriodicTask;
import com.framsticks.util.UnaryFunctor;
import com.framsticks.util.UnaryListenersSet;
import com.framsticks.util.dispatching.FutureHandler;
import com.framsticks.util.dispatching.RunAt;
import com.framsticks.util.dispatching.ThrowExceptionHandler;

@FramsClassAnnotation
public class SimulatorTree extends RemoteTree {

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

	protected Path simulator;

	/**
	 *
	 */
	public SimulatorTree() {
		super();
	}

	public void setRunning(final boolean running) {
		assert isActive();
		//simulator.call(simulator.getParam(running ? "start" : "stop", ProcedureParam.class), new LoggingStateCallback(log, (running ? "starting" : "stopping") + " server"));
	}

	protected final UnaryListenersSet<Boolean> simulationRunningListeners = new UnaryListenersSet<Boolean>();

	protected void updateSimulationRunning() {
		assert isActive();
		/*
		fetchValue(simulator, getParam(simulator, "running", Param.class), new StateFunctor() {
			@Override
			public void call(Exception e) {
				if (e != null) {
					log.fatal("failed to query simulator running status: " + e);
					return;
				}

				invokeLater(new Runnable() {
					@Override
					public void run() {
						boolean value = bindAccess(simulator).get("running", Boolean.class);
						log.trace("server running: " + value);
						simulationRunningListeners.call(value);
					}
				});

			}
		});
		 */
	}

	public void addRunningStateListener(UnaryFunctor<Boolean, Boolean> listener) {
		assert isActive();
		simulationRunningListeners.add(listener);
	}

	@Override
	protected void joinableStart() {
		super.joinableStart();

		dispatch(new RunAt<Tree>(ThrowExceptionHandler.getInstance()) {
			@Override
			protected void runAt() {
				tryGet(SimulatorTree.this, "/simulator", new FutureHandler<Path>(Logging.logger(log, "failed to resolve simulator node", SimulatorTree.this)) {
					@Override
					protected void result(Path path) {
						assert isActive();
						simulator = path;
						log.info("resolved simulator node");

						EventParam param = TreeOperations.getInfoFromCache(simulator).getParamEntry("running_changed", EventParam.class);

						assert param != null;
						connection.subscribe(simulator.getTextual() + "/" + param.getId(), SimulatorTree.this, new LoggingSubscriptionCallback<Tree>(log, "server running state change", new EventCallback() {
							@Override
							public void call(List<File> files) {
								dispatch(new RunAt<Tree>(getExceptionHandler()) {
									@Override
									protected void runAt() {
										updateSimulationRunning();
									}
								});
							}
						}));
						new PeriodicTask<Tree>(getExceptionHandler(), SimulatorTree.this, 1000) {
							@Override
							protected void runAt() {
								updateSimulationRunning();
								again();
							}
						};
					}
				});
			}
		});
	}

}