package jp.ac.u_ryukyu.treevnc.server;

import java.awt.event.*;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
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.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.ConnectionPresenter;
import com.glavsoft.viewer.Viewer;
import com.glavsoft.viewer.cli.Parser;
import com.glavsoft.viewer.mvp.View;
import com.glavsoft.viewer.swing.ClipboardControllerImpl;
import com.glavsoft.viewer.swing.ConnectionParams;
import com.glavsoft.viewer.swing.ParametersHandler;
import com.glavsoft.viewer.swing.Surface;
import com.glavsoft.viewer.swing.SwingConnectionWorkerFactory;
import com.glavsoft.viewer.swing.SwingViewerWindowFactory;
import com.glavsoft.viewer.swing.gui.ConnectionView;

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

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

	public static final int DEFAULT_PORT = 5900;
	public static Logger logger = Logger.getLogger("com.glavsoft");
	private boolean forceReconnection;
	private String reconnectionReason;
	private final ProtocolSettings settings;
	private AcceptThread acceptThread;
	private GetBroadCastProxy getCast;
	public AcceptClient aClient;
	public int opendPort;
	private Viewer view;

	private VncProxyService prevVps;
	static VncProxyService currentVps;
	private int fbWidth = 0;
	private int fbHeight = 0;

	private void initProxy(Parser parser) {
		aClient = new AcceptClient();
		ParametersHandler.completeSettingsFromCLI(parser, connectionParams,
				settings, uiSettings);
		passwordFromParams = parser.getValueFor(ParametersHandler.ARG_PASSWORD);
		logger.info("TightVNC Viewer version " + ver());
		isApplet = false;
	}
	
	public VncProxyService() {
	//	connectionParams = new ConnectionParams();
		settings = 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;
		aClient = vps.aClient;
		opendPort = vps.opendPort;
		prevVps = vps;
	}

	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();
		aClient = new AcceptClient();
		isApplet = false;
		setIsTreeVNC(true);
		setConnectionParam(hostName,5900);
		isApplet = true;
		run();
		createConnectionAndStart();
		getChangeScreenRequest(); // Should be used Client Socket.
		try {
			threadSetAndStart();
		} catch (UnknownHostException e) {

		} catch (IOException e) {

		}
	}

	private void setArguments(String[] mainArgs) {
	}

	private void cleanUpSession() {
		if (prevVps != null) {
			prevVps.cleanUpSession();
			prevVps = null;
		}
		// workingProtocol.cleanUpSession();
	}

	public void createConnectionAndStart() {
		Thread thread;
		opendPort = myRfb.selectPort(5999);
		//acceptThread = new AcceptThread(myRfb, opendPort);
		acceptThread = new AcceptThread(myRfb, opendPort);
		thread = new Thread(acceptThread);
		thread.start();
		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;
		fbHeight = height;
		proxyStart(argv);
	}

	public void proxyStart(String[] argv) {
		String[] mainArgs = 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(aClient);
		Thread thread = new Thread(createThread);
		thread.start();
		Thread thread2 = new Thread(new ChangeHost(this, forceReconnection));
		thread2.start();
	}

	private void getChangeScreenRequest() {
		Thread th = new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						Socket clientSocket = null;
						ServerSocket echoServer = new ServerSocket(10002);
						while (true) {
							clientSocket = echoServer.accept();
							BufferedReader is = new BufferedReader(
									new InputStreamReader(
											clientSocket.getInputStream()));
							String newHostName = is.readLine();
							//int width = Integer.parseInt(is.readLine());
							//int height = Integer.parseInt(is.readLine());
							// String screenSize = is.readLine();
							System.out.println(newHostName);
							if (permitChangeScreen()) {
								changeVNCServer(newHostName, 3200, 1980);
							} else {
								continue;
							}
							clientSocket.close();
						}
					} catch (IOException e) {
						continue; // log
					}
				}
			}
		});
		th.start();
	}

	private boolean permitChangeScreen() {

		return true;
	}

	protected void socketClose() {
	}

	@Override
	public void rfbSessionStopped(final String reason) {

	}

	private void createSocketAndSend(LinkedList<String> clientList,
			String host, String port) throws UnknownHostException, IOException {
		boolean passFlag = false;
		int counter = 0;
		for (String client : clientList) {
			if (passFlag) {
				Socket echoSocket = new Socket(client, 10001);
				DataOutputStream os = new DataOutputStream(
						echoSocket.getOutputStream());
				System.out.println(client);
				os.writeBytes("reconnection\n");
				if(counter++ < aClient.getTreeBranch())
					os.writeBytes(port + "\n");
				else 
					os.writeBytes(5999 + "\n");
				
				os.close();
			}
			passFlag = true;
		}
	}

	/**
	 * chnageVNCServer is called when host change.
	 * 
	 * @param hostName
	 *            HostAddress
	 * @param width
	 *            FrameWidth
	 * @param height
	 *            FrameHeight
	 */
	public void changeVNCServer(String hostName, int width, int height)
			throws UnknownHostException, IOException {
		// sender and reader stop
		VncProxyService newVps = new VncProxyService(this, hostName);
		// newVps.fbWidth = width;
		// newVps.fbHeight = height;
		// run call and change workingProtocol
		newVps.setConnectionParam(hostName, 5900);
		newVps.initProxy1(hostName);
		orderRecconection(newVps ,hostName);
		socketClose();
	}

	@Override
	public void settingsChanged(SettingsChangedEvent event) {

	}
	
	public void orderRecconection(VncProxyService vps,String hostName) throws UnknownHostException, IOException {
		int count  = 0;
		while(true) {
			if(vps.myRfb.getReadyReconnect()) {
				vps.createSocketAndSend(aClient.getList(), hostName, String.valueOf(vps.opendPort));
				break;
			} else {
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				if(count++ > 40) {
					break;
				} else {
					continue;
				}
			}
		}
	}
}