const { promisify } = require('util');
const dgram = require('dgram');
const { isIPv6, isIPv4 } = require('net');
const dns = require('dns-socket');
const HttpClient = require('../httpclient');

const emptyIP = '';
const defaults = {
	timeout: 3000,
	type: 'http', // 'http' | 'dns' | 'all'
};

const dnsServers = [
	{
		v4: {
			servers: [
				'208.67.222.222',
				'208.67.220.220',
				'208.67.222.220',
				'208.67.220.222',
			],
			name: 'myip.opendns.com',
			type: 'A',
		},
		v6: {
			servers: [
				'2620:0:ccc::2',
				'2620:0:ccd::2',
			],
			name: 'myip.opendns.com',
			type: 'AAAA',
		},
	},
];

const type = {
	v4: {
		dnsServers: dnsServers.map(({v4: {servers, ...question}}) => ({
			servers, question,
		})),
		httpsUrls: [
			'https://icanhazip.com/',
			'https://api.ipify.org/',
		],
	},
	v6: {
		dnsServers: dnsServers.map(({v6: {servers, ...question}}) => ({
			servers, question,
		})),
		httpsUrls: [
			'https://icanhazip.com/',
			'https://api6.ipify.org/',
		],
	},
};

const queryDns = (version, options) => {
	const data = type[version];
	const socket = dns({
		retries: 0,
		maxQueries: 1,
		socket: dgram.createSocket(version === 'v6' ? 'udp6' : 'udp4'),
		timeout: options.timeout,
	});

	const socketQuery = promisify(socket.query.bind(socket));
	const promise = (async () => {
		for (const dnsServerInfo of data.dnsServers) {
			const {servers, question} = dnsServerInfo;
			for (const server of servers) {
				if (socket.destroyed) {
					return emptyIP;
				}

				try {
					const {name, type, transform} = question;
					const dnsResponse = await socketQuery({questions: [{name, type}]}, 53, server);

					const {
						answers: {
							0: {
								data,
							},
						},
					} = dnsResponse;
					const response = (typeof data === 'string' ? data : data.toString()).trim();
          const ip = (transform && version === 'v6') ? transform(response) : response;
					const method = version === 'v6' ? isIPv6 : isIPv4;

					if (ip && method(ip)) {
						socket.destroy();
						return ip;
					}
				} catch (error) {
					// Log.coreLogger.error('[ee-core] [utils/ip] queryDns error:', error);
				}
			}
		}

		socket.destroy();
		return emptyIP;
	})();

	promise.cancel = () => {
		socket.destroy();
	};

	return promise;
};

const queryHttps = (version, options) => {
	let cancel;
  const hc = new HttpClient();

	const promise = (async () => {
		const requestOptions = {
			method: 'GET',
			timeout: options.timeout,
			dataType: 'text',
		};

		const urls = [
			...type[version].httpsUrls,
			...(options.fallbackUrls ?? []),
		];

		for (const url of urls) {
			try {
				const gotPromise = hc.request(url, requestOptions);
				gotPromise.cancel = () => {
					// todo
				}
				cancel = gotPromise.cancel;

				const response = await gotPromise;
				let result = response.status == 200 ? response.data : '';
				const ip = result.trim();

				const method = version === 'v6' ? isIPv6 : isIPv4;

				if (ip && method(ip)) {
					return ip;
				}
			} catch (error) {
				//Log.coreLogger.error('[ee-core] [utils/ip] queryHttps error:', error);
			}
		}

		return emptyIP;
	})();

	promise.cancel = function () {
		return cancel.apply(this);
	};

	return promise;
};

const queryAll = (version, options) => {
	let cancel;
	const promise = (async () => {
		let response;
		const dnsPromise = queryDns(version, options);
		cancel = dnsPromise.cancel;
		try {
			response = await dnsPromise;
		} catch {
			const httpsPromise = queryHttps(version, options);
			cancel = httpsPromise.cancel;
			response = await httpsPromise;
		}

		return response;
	})();

	promise.cancel = cancel;

	return promise;
};

/**
 * 查询 public ipv4
 */  
function publicIpv4(options) {
  options = {
    ...defaults,
    ...options,
  };

  if (options.type == 'http') {
    return queryHttps('v4', options);
  }	
	
  if (options.type == 'dns') {
    return queryDns('v4', options);
  }

  return queryAll('v4', options);
}

/**
 * 查询public ipv6
 */  
function publicIpv6(options) {
  options = {
    ...defaults,
    ...options,
  };

  if (options.type == 'http') {
    return queryHttps('v6', options);
  }	
	
  if (options.type == 'dns') {
    return queryDns('v6', options);
  }

  return queryAll('v6', options);
}

/**
 * todo 未来趋势是ipv6优先，以后再放开
 */  
const publicIp = createPublicIp(publicIpv4, publicIpv6);
function createPublicIp(publicIpv4, publicIpv6) {
	return function publicIp(options) {
		const ipv4Promise = publicIpv4(options);
		const ipv6Promise = publicIpv6(options);

		const promise = (async () => {
			try {
				const ipv6 = await ipv6Promise;
				ipv4Promise.cancel();
				return ipv6;
			} catch (ipv6Error) {
				//Log.coreLogger.error('[ee-core] [utils/ip] publicIp ipv6Error:', ipv6Error);
				try {
					return await ipv4Promise;
				} catch (ipv4Error) {
					//Log.coreLogger.error('[ee-core] [utils/ip] publicIp ipv4Error:', ipv4Error);
				}
			}
		})();

		promise.cancel = () => {
			ipv4Promise.cancel();
			ipv6Promise.cancel();
		};

		return promise;
	};
}

const IP = {
  //publicIp,
  publicIpv4,
  publicIpv6
}

module.exports = IP;