package jp.ac.u_ryukyu.treevnc.server;

import java.awt.event.*;
import java.io.*;
import java.net.UnknownHostException;
import java.util.LinkedList;
import java.util.logging.Logger;

import jp.ac.u_ryukyu.treevnc.TreeVncCommandChannelListener;
import com.glavsoft.core.SettingsChangedEvent;
import com.glavsoft.rfb.IChangeSettingsListener;
import com.glavsoft.rfb.IRfbSessionListener;
import com.glavsoft.rfb.protocol.ProtocolSettings;
import com.glavsoft.viewer.Viewer;
import com.glavsoft.viewer.cli.Parser;
import com.glavsoft.viewer.swing.ConnectionParams;
import com.glavsoft.viewer.swing.ParametersHandler;

public class VncProxyService extends Viewer implements Runnable,
		IRfbSessionListener, IChangeSettingsListener {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	public static Logger logger = Logger.getLogger("com.glavsoft");
	private boolean forceReconnection;
	private String reconnectionReason;
	private TreeVncCommandChannelListener acceptThread;
	private TreeRootFinderListener getCast;
	private TreeManagement clients;
	static VncProxyService currentVps;
	private int fbWidth = 0;
	private boolean firstTime = true;

    private int vncport = ConnectionParams.DEFAULT_RFB_PORT;

	public VncProxyService() {
	ProtocolSettings.getDefaultSettings();
		uiSettings = super.uiSettings;
	}

	public VncProxyService(VncProxyService vps, String hostName) {
		this();
		connectionParams.hostName = hostName;
		myRfb = vps.myRfb;
		forceReconnection = vps.forceReconnection;
		reconnectionReason = vps.reconnectionReason;
		acceptThread = vps.acceptThread;
		getCast = vps.getCast;
		clients = vps.clients;
	}

	public static void main(String[] argv) {
		String[] mainArgs = argv;
		System.out.println(mainArgs.length);
		// input into arguments Decision

		Parser parser = new Parser();
		ParametersHandler.completeParserOptions(parser);

		parser.parse(argv);
		if (parser.isSet(ParametersHandler.ARG_HELP)) {
			printUsage(parser.optionsUsage());
			System.exit(0);
		}
		VncProxyService vps = new VncProxyService();
		vps.initRoot("localhost");
	}

	private void initRoot(String hostName) {
		myRfb = new MyRfbProtoProxy();
		myRfb.setVncProxy(this);
		clients = new TreeManagement(hostName, vncport,myRfb);
		isApplet = false;
		setIsTreeVNC(true);
		setConnectionParam(hostName,vncport);
		isApplet = true;
		run();
		createConnectionAndStart();
	}
	
	/**
	 * start new VNC server receiver with
	 * inherited clients
	 * @param vs
	 * @param hostName
	 */
	private void inhelitClients(VncProxyService vs, String hostName) {
		myRfb.setReadyReconnect(false);
		setConnectionParam(hostName,vncport);
		isApplet = true;
		this.setNoConnection(false);
		run();
		firstTime = false;
		createConnectionAndStart();
	}

	/**
	 * start accepting children
	 * run rootFinderListener if necessary
	 */
	public void createConnectionAndStart() {
		myRfb.selectPort(ConnectionParams.DEFAULT_VNC_ROOT);
		acceptThread = new TreeVncCommandChannelListener(myRfb, myRfb.getAcceptPort());
		Thread thread = new Thread(acceptThread, "TreeVNC-accept");
		thread.start();
		if(firstTime) {
			getCast = new TreeRootFinderListener(this);
			thread = new Thread(getCast, "tree-root-find-listener");
			thread.start();
		}
	}

	public void proxyStart(String[] argv, int width, int height) {
		fbWidth = width;
		proxyStart(argv);
	}

	public void proxyStart(String[] argv) {
		// input into arguments Decision
		Parser parser = new Parser();
		ParametersHandler.completeParserOptions(parser);
		if (fbWidth == 0)
			parser.parse(argv);
		if (parser.isSet(ParametersHandler.ARG_HELP)) {
			printUsage(parser.optionsUsage());
			System.exit(0);
		}
		initRoot("localhost");
	}

	@Override
	public void destroy() {

	}

	@Override
	public void windowClosing(WindowEvent e) {
		if (e != null && e.getComponent() != null) {
			e.getWindow().setVisible(false);
		}
		closeApp();
	}

	protected void socketClose() {
	}

	@Override
	public void rfbSessionStopped(final String reason) {

	}


	/**
	 * chnageVNCServer is called when host change.
	 * 
	 * @param hostName
	 *            HostAddress
	 * @param width
	 *            FrameWidth
	 * @param height
	 *            FrameHeight
	 * @throws InterruptedException 
	 */
	public void changeVNCServer(String hostName, int width, int height)
			throws UnknownHostException, IOException, InterruptedException {
		// stop reader stop
	    myRfb.stopReceiverTask();
		inhelitClients(this, hostName);
		orderRecconection(hostName);
	}

	@Override
	public void settingsChanged(SettingsChangedEvent event) {

	}
	
	public void setFirstTime(boolean flag) {
		firstTime = flag;
	}
	
	public void orderRecconection(String hostName) throws UnknownHostException, IOException, InterruptedException {
		myRfb.waitForReady(this);
		myRfb.sendDesktopSizeChange();
	}

	public  LinkedList<TreeVNCNode> clientList() {
		return clients.getList();
	}

    public void decideWhereToConnect(String hostname, int port,String localhostname) {
        clients.decideWhereToConnect(hostname,port,localhostname);
    }

    public void fixLostParent(String hostname, int port) {
        clients.fixLostParent(hostname,port);
    }

    public  TreeVncCommandChannelListener getAcceptThread() {
        return this.acceptThread;
    }
}