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 XMLRPC_VARIABLE = "axis";
	private static final String ENABLED_KEY = "enabled";
	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 = "btnEnableDaemon")
	private InputButton enableDaemonButton;

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

    @Input(id = "btnReady")
    private InputButton refButtonrReady;

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

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

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

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

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


	@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 = "btnReady")
    public void onBtnReady(InputEvent event) {
        if (event.getEventType() == InputEvent.EventType.ON_RELEASED) {
            try {
                getDaemonInterface().client.execute("ready", new String[]{});
            } 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");
		refButtonrReady.setText("Ready");
		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);

	}

	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()+"\")");
	    writer.writeChildren();
	}


	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 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;
    }
}