package jp.ac.u_ryukyu.treevnc.server;

import java.awt.event.*;
import java.io.*;
import java.util.logging.Logger;

import jp.ac.u_ryukyu.treevnc.AcceptThread;



import com.glavsoft.exceptions.AuthenticationFailedException;
import com.glavsoft.exceptions.FatalException;
import com.glavsoft.exceptions.TransportException;
import com.glavsoft.exceptions.UnsupportedProtocolVersionException;
import com.glavsoft.exceptions.UnsupportedSecurityTypeException;
import com.glavsoft.rfb.IChangeSettingsListener;
import com.glavsoft.rfb.IRfbSessionListener;
import com.glavsoft.rfb.protocol.Protocol;
import com.glavsoft.rfb.protocol.ProtocolSettings;
import com.glavsoft.transport.Reader;
import com.glavsoft.transport.Writer;
import com.glavsoft.viewer.ConnectionManager;
import com.glavsoft.viewer.Viewer;
import com.glavsoft.viewer.cli.Parser;
import com.glavsoft.viewer.swing.ClipboardControllerImpl;
import com.glavsoft.viewer.swing.ParametersHandler;
import com.glavsoft.viewer.swing.Surface;
import com.glavsoft.viewer.swing.UiSettings;
import com.glavsoft.viewer.swing.ParametersHandler.ConnectionParams;

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

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

	public MyRfbProtoProxy rfb;
	private ConnectionManager connectionManager;
	// public AcceptClient acc;
	public VncProxyService(Parser parser) {
		this();
		rfb = new MyRfbProtoProxy();
		ParametersHandler.completeSettingsFromCLI(parser, connectionParams, settings, uiSettings);
		showControls = ParametersHandler.showControls;
		passwordFromParams = parser.getValueFor(ParametersHandler.ARG_PASSWORD);
		logger.info("TightVNC Viewer version " + ver());
		isApplet = false;
	}
	
	public VncProxyService() {
		connectionManager = new ConnectionManager(this, isApplet);
		connectionParams = new ParametersHandler.ConnectionParams();
		settings = ProtocolSettings.getDefaultSettings();
		uiSettings = super.uiSettings;
	}
	
	boolean isClient = false;
	public static final int DEFAULT_PORT = 5900;
	public static Logger logger = Logger.getLogger("com.glavsoft");
	private boolean forceReconnection;
	private String reconnectionReason;
	private ConnectionParams connectionParams;
	private final ProtocolSettings settings;
	private final UiSettings uiSettings;
	private Thread bCast;
	private Thread accThread;
	private AcceptThread acceptThread;
	private GetBroadCastProxy getCast;
	
	
	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(parser);
		if (mainArgs.length != 0) {
			for (int i = 0; i < argv.length; i++) {
				vps.setArguments(mainArgs);
				// write later
			}
		} else {
			//getHostData();
		}
		//SwingUtilities.invokeLater(myClient);
		Thread th = new Thread(vps);
		th.start();
		try {
			th.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		vps.createConnection();
		vps.start_threads();
	}
	
	private void setArguments(String[] mainArgs) {
	}

	@Override
	public void run() {
	//	getHostData();
		if (forceReconnection) {
			connectionManager.showReconnectDialog("Connection lost", reconnectionReason);
			forceReconnection = false;
		}
		tryAgain = true;
		while (tryAgain) {
		//  connectionParams.hostName = arguments[0];
		//	workingSocket = connectionManager.connectToTreeHost(connectionParams, settings);
			workingSocket = connectionManager.connectToHost(connectionParams, settings, rfb);
			if (null == workingSocket) {
				closeApp();
				break;
			}
			logger.info("Connected");

			try {
				workingSocket.setTcpNoDelay(true); // disable Nagle algorithm
				Reader reader = new Reader(workingSocket.getInputStream());
				Writer writer = new Writer(workingSocket.getOutputStream());
		//		rfb.setStream(reader,writer);
				workingProtocol = new Protocol(reader, writer,
						new PasswordChooser(passwordFromParams, connectionParams, containerFrame, this),
						settings);
				threadSetAndStart();
				workingProtocol.handshake();
				rfb.setProtocolContext(workingProtocol);
				// input into change parents
                ClipboardControllerImpl clipboardController =
		                new ClipboardControllerImpl(workingProtocol, settings.getRemoteCharsetName());
				clipboardController.setEnabled(settings.isAllowClipboardTransfer());
				settings.addListener(clipboardController);
				surface = new Surface(workingProtocol, this, uiSettings.getScaleFactor()); // this method
				settings.addListener(this);
				uiSettings.addListener(surface);
				containerFrame = createContainer();
				connectionManager.setContainerFrame(containerFrame);
				updateFrameTitle();
				containerFrame.dispose();
				containerFrame = null;
				workingProtocol.startNormalHandling(this, surface, clipboardController,rfb);
				// rfb.setInitData(workingProtocol.getInitData()); too early
				// workingProtocol.startNormalHandling(this, surface, clipboardController);
				tryAgain = false;
			} catch (UnsupportedProtocolVersionException e) {
				connectionManager.showReconnectDialog("Unsupported Protocol Version", e.getMessage());
				logger.severe(e.getMessage());
			} catch (UnsupportedSecurityTypeException e) {
				connectionManager.showReconnectDialog("Unsupported Security Type", e.getMessage());
				logger.severe(e.getMessage());
			} catch (AuthenticationFailedException e) {
				passwordFromParams = null;
				connectionManager.showReconnectDialog("Authentication Failed", e.getMessage());
				logger.severe(e.getMessage());
			} catch (TransportException e) {
				connectionManager.showReconnectDialog("Connection Error", "Connection Error" + ": " + e.getMessage());
				logger.severe(e.getMessage());
			} catch (IOException e) {
				connectionManager.showReconnectDialog("Connection Error", "Connection Error" + ": " + e.getMessage());
				logger.severe(e.getMessage());
			} catch (FatalException e) {
				connectionManager.showReconnectDialog("Connection Error", "Connection Error" + ": " + e.getMessage());
				logger.severe(e.getMessage());
			}
		}
	}
	
	public void createConnection() {
		rfb.selectPort(5999);
		acceptThread = new AcceptThread(rfb, 5999);
		accThread = new Thread(acceptThread);
		getCast = new GetBroadCastProxy(this,
				workingProtocol.getRemoteDesktopName(),
				this.connectionParams.hostName);
		bCast = new Thread(getCast);		
	}
	
	public void start_threads() {
		//rfbThread.start();
		accThread.start();
		bCast.start();
		//rfb.requestThreadStart();
	}

	public void proxyStart(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(parser);
		if (mainArgs.length != 0) {
			for (int i = 0; i < argv.length; i++) {
				vps.setArguments(mainArgs);
				// write later
			}
		} else {
			//getHostData();
		}
		//SwingUtilities.invokeLater(myClient);
		Thread th = new Thread(vps);
		th.start();
		try {
			th.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		vps.createConnection();
		vps.start_threads();
	}

	
	@Override
	public void destroy() {

	}

	@Override
	public void windowClosing(WindowEvent e) {
		if (e != null && e.getComponent() != null) {
			e.getWindow().setVisible(false);
		}
		closeApp();
	}
	
	private void threadSetAndStart() {
		AcceptClient aClient = new AcceptClient(connectionParams.hostName);
		Thread thread = new Thread(new CreateThread(aClient));
		thread.start();
		thread = new Thread(new ChangeHost(this, forceReconnection));
		thread.start();
		
	}
	
	public void setConnectionManager(ConnectionManager _connectionManager) {
		connectionManager = _connectionManager;
	}
}