const Component = require("./_component");
const net = require('net');
const fs = require('fs');

function logger (...p) {
	return;
	console.debug("[TCP reverse]:", ...p);
};

async function isFirewalled () {  // TODO: Firewall
	return false;
}

module.exports = class TCPServer extends Component {
	static type () {
		return "tcp-proxy";
	}

	constructor (adr, syntaxTree) {
		super(adr, syntaxTree);
		if (syntaxTree.firewall) {
			throw new Error("Firewall doesn't supports");
		}
	}
	
	run () {
		this.server = net.createServer(async (srvSocket) => {
			const isFrw = await isFirewalled(srvSocket.remoteAddress);
			if (isFrw) {
				srvSocket.end();
				logger(`${srvSocket.remoteAddress} firewalled, reject`);
			}
			srvSocket.on("error", (err) => {
				logger("Caught server socket error: ");
				logger(err.stack);
			});
		});
		const connections = {};
		
		this.server.on('connection', async (socket) => {
			socket.fullAddress = `${socket.remoteAddress}:${socket.remotePort}`;
			
			//const loggerPromise = loggingIp(`${this.adr.address}:${this.adr.port}`, socket.remoteAddress, new Date());
			const isFrw = await isFirewalled(socket.remoteAddress);
			if (isFrw) {
				socket.end();
				logger(`${socket.remoteAddress} firewalled, reject`);
				//await loggerPromise;
				return;
			}
			else {
				//await loggerPromise;
				const remote = {
					ip: this.syntax.target.split(/:/)[0],
					port: this.syntax.target.split(/:/)[1],
				};
				connections[socket.fullAddress] = net.createConnection(remote.port, remote.ip);
				logger(`${socket.remoteAddress} was been connected, connect to remote created`);
				
				socket.on('data', (data) => {
					logger(`from ${socket.remoteAddress} sended: ${data.length} bytes`);
					connections[socket.fullAddress].write(data, function(err) {
						if (err)
							logger(`error: ${socket.remoteAddress} throwed: ${err.name}`);
						// connections[socket.fullAddress].end();
					});
					// connections[socket.fullAddress].end();
				});
				
				connections[socket.fullAddress].on('data', (data) => {
					logger(`to ${socket.remoteAddress} sended: ${data.length} bytes`);
					socket.write(data, function(err) {
						if (err)
							logger(`error: ${socket.remoteAddress} (remote) throwed: ${err.name}`);
						// socket.end();
					});
					// socket.end();
				});
				
				connections[socket.fullAddress].on('end', (data) => {
					logger(`remote of ${socket.remoteAddress} disconnected`);
					socket.end();
				});
				
				connections[socket.fullAddress].on('error', (err) => {
					logger(`remote of ${socket.remoteAddress} error:`);
					logger(err.stack);
					socket.end();
				});
				
				socket.on('end', () => {
					logger(`${socket.remoteAddress} disconnected`);
					connections[socket.fullAddress].end();
					connections[socket.fullAddress] = undefined; // Free memory!
				});
				
				socket.on("error", (err) => {
					logger(
						`socket.on(${socket.remoteAddress}) error:`
					);
					logger(err.stack);
					connections[socket.fullAddress].end();
					// socket.end();
				});
			}
		});
		
		this.server.on('error', (err) => {
			logger("Error of server");
			logger(err.stack);
		});
		
		this.server.listen(this.adr.port, this.adr.address, (err) => {
			if (err) throw err;
			console.log("TCP reverse proxy connected!");
		});
	}
}