uraxis/src/main/java/uraxis/MyDaemonInstallationNodeContribution.java

package uraxis;

import com.ur.urcap.api.contribution.DaemonContribution;
import com.ur.urcap.api.contribution.InstallationNodeContribution;
import com.ur.urcap.api.domain.data.DataModel;
import com.ur.urcap.api.domain.script.ScriptWriter;
import com.ur.urcap.api.ui.annotation.Div;
import com.ur.urcap.api.ui.annotation.Input;
import com.ur.urcap.api.ui.annotation.Label;
import com.ur.urcap.api.ui.component.*;
import org.apache.xmlrpc.XmlRpcException;

import java.awt.EventQueue;
import java.util.Timer;
import java.util.TimerTask;

public class MyDaemonInstallationNodeContribution implements InstallationNodeContribution {
	private static final String POPUPTITLE_KEY = "popuptitle";
	private static final String XMLRPC_VARIABLE = "my_daemon";
	private static final String ENABLED_KEY = "enabled";
	private static final String DEFAULT_VALUE = "HelloWorld";
	private static final String IP = "ip";
	private static final String PORT = "port";

	private DataModel model;
	// private final MyDaemonDaemonService daemonService;
	private MyDaemonInterface daemonInterface;

	private Timer uiTimer;
	private Timer statusTimer;

	public MyDaemonInstallationNodeContribution(MyDaemonDaemonService daemonService, DataModel model) {
		// this.daemonService = daemonService;
		this.model = model;
		daemonInterface = new MyDaemonInterface(getIP(), Integer.parseInt(getPort()));
		// applyDesiredDaemonStatus();
        Activator.daemonInterface=daemonInterface;
	}

	@Input(id = POPUPTITLE_KEY)
	private InputTextField popupTitleField;

	@Input(id = "btnEnableDaemon")
	private InputButton enableDaemonButton;

	@Input(id = "btnRef")
	private InputButton refButtonRef;

	@Input(id = "textIP")
	private InputTextField refTextIP;

	@Input(id = "textPort")
	private InputTextField refTextPort;

	@Label(id = "lblStatus")
	private LabelComponent refLblStatus;

	@Input(id = "numberPos")
	private InputTextField refNumberPos;

	@Input(id = "btnPos")
	private InputButton refButtonPos;

	@Input(id = "btnDisableDaemon")
	private InputButton disableDaemonButton;

	@Label(id = "lblDaemonStatus")
	private LabelComponent daemonStatusLabel;

	@Input(id = POPUPTITLE_KEY)
	public void onMessageChange(InputEvent event) {
		if (event.getEventType() == InputEvent.EventType.ON_CHANGE) {
			setPopupTitle(popupTitleField.getText());
		}
	}
	@Input(id = "btnRef")
	public void onBtnRef(InputEvent event) {
		if (event.getEventType() == InputEvent.EventType.ON_CHANGE) {
			try {
				getDaemonInterface().client.execute("ref", new String[]{"foo", "bar"});
			} catch (XmlRpcException e) {
				e.printStackTrace();
			}
		}
	}

	@Input(id = "btnPos")
	public void onBtnPos(InputEvent event) {
		if (event.getEventType() == InputEvent.EventType.ON_CHANGE) {
			try {
				String pos=refNumberPos.getText();
				getDaemonInterface().client.execute("pos", new String[]{pos});
			} catch (XmlRpcException e) {
				e.printStackTrace();
			}
		}
	}

	@Input(id = "btnEnableDaemon")
	public void onStartClick(InputEvent event) {
		if (event.getEventType() == InputEvent.EventType.ON_CHANGE) {
			setDaemonEnabled(true);
			// applyDesiredDaemonStatus();
		}
	}

	@Input(id = "btnDisableDaemon")
	public void onStopClick(InputEvent event) {
		if (event.getEventType() == InputEvent.EventType.ON_CHANGE) {
			setDaemonEnabled(false);
			// applyDesiredDaemonStatus();
		}
	}

	@Override
	public void openView() {
		enableDaemonButton.setText("Start Daemon");
		disableDaemonButton.setText("Stop daemon");
		popupTitleField.setText(getPopupTitle());
		refTextIP.setText(getIP());
		refTextPort.setText(getPort());

		//UI updates from non-GUI threads must use EventQueue.invokeLater (or SwingUtilities.invokeLater)
		uiTimer = new Timer(true);
		uiTimer.schedule(new TimerTask() {
			@Override
			public void run() {
				EventQueue.invokeLater(new Runnable() {
					@Override
					public void run() {
						updateUI();
					}
				});
			}
		}, 0, 1000);

//		statusTimer = new Timer(true);
//		statusTimer.schedule(new TimerTask() {
//			@Override
//			public void run() {
//				EventQueue.invokeLater(new Runnable() {
//					@Override
//					public void run() {
//						try {
//							Object res = getDaemonInterface().client.execute("status", new String[]{});
//							refLblStatus.setText("<html>"+res.toString()+"</html>");
//							System.out.println(res);
//						} catch (XmlRpcException e) {
//							e.printStackTrace();
//						}
//					}
//				});
//		}},0,1000);
	}

	private void updateUI() {
		DaemonContribution.State state = getDaemonState();

		if (state == DaemonContribution.State.RUNNING) {
			enableDaemonButton.setEnabled(false);
			disableDaemonButton.setEnabled(true);
		} else {
			enableDaemonButton.setEnabled(true);
			disableDaemonButton.setEnabled(false);
		}

		String text = "";
		switch (state) {
		case RUNNING:
			text = "My Daemon runs";
			break;
		case STOPPED:
			text = "My Daemon stopped";
			break;
		case ERROR:
			text = "My Daemon failed";
			break;
		}
		daemonStatusLabel.setText(text);
	}

	@Override
	public void closeView() {
		if (uiTimer != null) {
			uiTimer.cancel();
		}

		setIP(refTextIP.getText());
		setPort(refTextPort.getText());
	}

	@Override
	public void generateScript(ScriptWriter writer) {
		writer.assign(XMLRPC_VARIABLE, "rpc_factory(\"xmlrpc\", \"http://"+ getIP()+":"+ getPort()+"\")");
	}

	public String getPopupTitle() {
		if (!model.isSet(POPUPTITLE_KEY)) {
			resetToDefaultValue();
		}
		return model.get(POPUPTITLE_KEY, DEFAULT_VALUE);
	}


	private void setPopupTitle(String title) {
		if ("".equals(title)) {
			resetToDefaultValue();
		} else {
			model.set(POPUPTITLE_KEY, title);
			// Apply the new setting to the daemon for real-time preview purposes
			// Note this might influence a running program, since the actual state is stored in the daemon.
			setDaemonTitle(title);
		}
	}

	public String getIP() {
		return  model.get(IP, "127.0.0.1");
	}

	public void setIP(String ip) {
		model.set(IP, ip);
	}

	public String getPort() {
		return  model.get(PORT, "8080");
	}

	public void setPort(String ip) {
		model.set(PORT, ip);
	}


	private void resetToDefaultValue() {
		popupTitleField.setText(DEFAULT_VALUE);
		model.set(POPUPTITLE_KEY, DEFAULT_VALUE);
		setDaemonTitle(DEFAULT_VALUE);
	}

	private void setDaemonTitle(String title) {
		try {
			daemonInterface.setTitle(title);
		} catch(Exception e){
			System.err.println("Could not set the title in the daemon process.");
		}
	}

//	private void applyDesiredDaemonStatus() {
//		new Thread(new Runnable() {
//			@Override
//			public void run() {
//				if (isDaemonEnabled()) {
//					// Download the daemon settings to the daemon process on initial start for real-time preview purposes
//					try {
//						awaitDaemonRunning(5000);
//						daemonInterface.setTitle(getPopupTitle());
//					} catch (Exception e) {
//						System.err.println("Could not set the title in the daemon process.");
//					}
//				} else {
//					daemonService.getDaemon().stop();
//				}
//			}
//		}).start();
//	}

//	private void awaitDaemonRunning(long timeOutMilliSeconds) throws InterruptedException {
//		daemonService.getDaemon().start();
//		long endTime = System.nanoTime() + timeOutMilliSeconds * 1000L * 1000L;
//		while(System.nanoTime() < endTime && (daemonService.getDaemon().getState() != DaemonContribution.State.RUNNING || !daemonInterface.isReachable())) {
//			Thread.sleep(100);
//		}
//	}
//
	private DaemonContribution.State getDaemonState(){
		return DaemonContribution.State.RUNNING;
		// return daemonService.getDaemon().getState();
	}

	private Boolean isDaemonEnabled() {
		return model.get(ENABLED_KEY, true); //This daemon is enabled by default
	}

	private void setDaemonEnabled(Boolean enable) {
		model.set(ENABLED_KEY, enable);
	}

	public String getXMLRPCVariable(){
		return XMLRPC_VARIABLE;
	}

	public MyDaemonInterface getDaemonInterface() {return daemonInterface; }

    public boolean isDefined() {
		return true;
    }
}