import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class AsyncSocket {
	private Socket socket;
	private Thread checkerThread;
	private Thread connectorThread;
	private AsyncSocketListener handler;
	private boolean shouldStop = false;

	private String sendBuffer = "";

	private BufferedReader in;
	private BufferedWriter out;

	public AsyncSocket(int port, AsyncSocketListener handler) {
		this.setHandler(handler);

		// start server in new thread
		this.connectorThread = new Thread(() -> {
			try {
				ServerSocket serverSocket = new ServerSocket(port);

				System.out.println("Waiting for client connection on port " + port);

				Socket socket = serverSocket.accept();

				System.out.println("Socket connected.");

				serverSocket.close();

				this.initSocket(socket);

			} catch (IOException e) {
				e.printStackTrace();
				// TODO: proper error handling
			}
		});
		this.connectorThread.start();
	}

	public AsyncSocket(InetSocketAddress address, AsyncSocketListener handler) {
		this.setHandler(handler);

		// start client in new thread
		this.connectorThread = new Thread(() -> {
			System.out.println("Connecting to " + address.toString());

			Socket socket = new Socket();
			try {
				socket.connect(address, 10);
				System.out.println("Socket connected.");

				this.initSocket(socket);

			} catch (IOException e) {
				e.printStackTrace();
				throw new RuntimeException("Connection timed out");
			}

		});
		this.connectorThread.start();
	}

	public AsyncSocket(Socket socket, AsyncSocketListener handler) throws IOException {
		this.setHandler(handler);
		this.initSocket(socket);
	}

	private void initSocket(Socket socket) throws IOException {
		System.out.println("Initialising sockets");
		this.socket = socket;

		this.in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
		this.out = new BufferedWriter(new OutputStreamWriter(this.socket.getOutputStream()));

		this.shouldStop = false;
		this.checkerThread = new Thread(() -> {
			while (!this.shouldStop) {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

				if (!this.connectorThread.isAlive()) {
					try {
						this.connectorThread.join();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}

				try {
					if (!this.in.ready()) {
						continue;
					}
					if (this.handler == null) {
						continue;
					}

					String message = this.in.readLine();
					if (message.length() <= 0) continue;


					message = message.strip();
					System.out.println("RECEIVED - " + message);
					this.handler.receive(message);
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		});
		System.out.println("starting checker thread");
		this.checkerThread.start();
		this.flushBuffer();
	}

	public void setHandler(AsyncSocketListener handler) {
		this.handler = handler;
	}


	public synchronized void send(SocketPackage socketPackage) {
		this.sendLine(socketPackage.toString());
	}
	public synchronized void send(String packageName) {
		this.send(packageName, "");
	}
	public synchronized void send(String packageName, String packageContent) {
		if (packageContent.length() > 0) {
			packageContent = " " + packageContent;
		}
		this.sendLine(packageName + packageContent);
	}

	public synchronized void sendLine(String message) {
		sendBuffer = sendBuffer + message + "\r\n";
		this.flushBuffer();
	}

	private synchronized void flushBuffer() {
		if (!this.sendBuffer.isEmpty() && this.out != null) {
			try {
				this.out.write(sendBuffer);
				System.out.println("SENT - " + sendBuffer);
				sendBuffer = "";
				this.out.flush();
			} catch (IOException e) {
				e.printStackTrace();
				// TODO: handle writing error
			}
		}
	}

	public void close() {
		this.shouldStop = true;
		
		try {
			this.socket.close();
			this.checkerThread.join();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}