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.AcceptThread;
import jp.ac.u_ryukyu.treevnc.server.state.ChangeHost;

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 AcceptThread acceptThread;
	private GetBroadCastProxy getCast;
	private AcceptClient clients;
	public int opendPort;
	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;
		opendPort = vps.opendPort;
	}

	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.initProxy1("localhost");
	}

	private void initProxy1(String hostName) {
		myRfb = new MyRfbProtoProxy();
		myRfb.setVncProxy(this);
		clients = new AcceptClient();
		isApplet = false;
		setIsTreeVNC(true);
		setConnectionParam(hostName,vncport);
		isApplet = true;
		run();
		createConnectionAndStart();
		try {
			threadSetAndStart();
		} catch (UnknownHostException e) {

		} catch (IOException e) {

		}
	}
	
	/**
	 * 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();
	}

	public void createConnectionAndStart() {
		Thread thread;
		opendPort = myRfb.selectPort(5999);
		acceptThread = new AcceptThread(myRfb, opendPort);
		thread = new Thread(acceptThread, "TreeVNC-accept");
		thread.start();
		if(firstTime) {
			getCast = new GetBroadCastProxy(this,
					this.connectionParams.getHostName(),
					this.connectionParams.getHostName());
			thread = new Thread(getCast);
			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);
		}
		initProxy1("localhost");
	}

	@Override
	public void destroy() {

	}

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

	private void threadSetAndStart() throws UnknownHostException, IOException {
		CreateThread createThread = new CreateThread(clients);
		Thread thread = new Thread(createThread);
		thread.start();
		Thread thread2 = new Thread(new ChangeHost(this, forceReconnection));
		thread2.start();
	}

	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<String> clientList() {
		return clients.getList();
	}
}