import { Helpers, _, MOBILE } from "./Helpers";

export module Functions {

	//#region private
	async function checkForPort(ip: string): Promise<number> {
		return new Promise<number>(async (resolve, reject) => {
			new Helpers.WebSocketRequest(
				ip,
				JSON.stringify({
					type: "servicePortsInformationRequest",
					uuid: Helpers.GenUuid()
				})
			)
				.GetResponseAsync()
				.then(response => {
					for (let p of JSON.parse(response).data[0].services) {
						if (p.nameAbbrevation === "ism") {
							return resolve(p.ports[0].number);
						}
					}
					return reject();
				})
				.catch(() => {
					return reject();
				});
		});
	}

	async function retrieveDataIp(tryLocalhostFirst: boolean): Promise<string> {
		return new Promise<string>((resolve, reject) => {
			const localhost: string = "ws://localhost";
			const defaultIp: string = "ws://192.168.133.140";
			const portToCheck: number = 7300;
			if (tryLocalhostFirst) {
				checkForPort(`${localhost}:${portToCheck}`)
					.then(port => {
						return resolve(`${localhost}:${port}`);
					})
					.catch(() =>
						checkForPort(`${defaultIp}:${portToCheck}`)
							.then(port => {
								return resolve(`${defaultIp}:${port}`);
							})
							.catch(() => {
								return reject();
							})
					);
			} else {
				checkForPort(`${defaultIp}:${portToCheck}`)
					.then(port => resolve(`${defaultIp}:${port}`))
					.catch(() =>
						checkForPort(`${localhost}:${portToCheck}`)
							.then(port => {
								return resolve(`${localhost}:${port}`);
							})
							.catch(() => {
								return reject();
							})
					);
			}
		});
	}

	async function loadData(ip: string): Promise<any> {
		return new Promise<any>((resolve, reject) => {
			new Helpers.WebSocketRequest(
				ip,
				JSON.stringify({
					type: "getEssentials",
					uuid: Helpers.GenUuid()
				})
			)
				.GetResponseAsync()
				.then(data => resolve(JSON.parse(data).data))
				.catch(() => {
					return reject();
				});
		});
	}

	async function manualLoadData(): Promise<any> {
		return new Promise<any>(async (resolve, reject) => {
			let data: any;
			let serverIp: string = "ws://192.168.133.140:2080";
			do {
				serverIp = prompt(
					"Unable to load data automatically. Please enter ip:",
					serverIp
				) as string;
				try {
					data = await loadData(serverIp);
				} catch {
					continue;
				}
			} while (_(data));
			webSocketIp = serverIp;
			return resolve(data);
		});
	}

	function storeInCache(key: string, value: any): void {
		window.localStorage.setItem(key, escape(JSON.stringify(value)));
	}

	function retrieveFromCache(key: string): any | never {
		let value = window.localStorage.getItem(key);
		if (!_(value)) return JSON.parse(unescape(value as string));
		else throw new Error();
	}
	//#endregion

	/**
	 * Tries to load the data automatically from the websocket,
	 * then from cache, then from the user. Always caches the
	 * response.
	 */
	export async function GetData(): Promise<any> {
		return new Promise<any>(async (resolve, reject) => {
			var data: any;
			try {
				let serverIp = await retrieveDataIp(!MOBILE);
				data = await loadData(serverIp);
				webSocketIp = serverIp;
			} catch {
				try {
					data = retrieveFromCache("data");
				} catch {
					data = await manualLoadData();
				}
			} finally {
				storeInCache("data", data);
				return resolve(data);
			}
		});
	}

	var webSocketIp: string | null = null;

	export async function GetMountedAssetIp(Id: number): Promise<string> {
		return new Promise<string>(async (resolve, reject) => {
			if (_(webSocketIp)) return reject();
			try {
				let ip: string = JSON.parse(
					await new Helpers.WebSocketRequest(
						webSocketIp as string,
						JSON.stringify({
							type: "getAssetState",
							uuid: Helpers.GenUuid(),
							data: {
								assetId: Id
							}
						})
					).GetResponseAsync()
				).data.ipAddr;
				if (!_(ip)) return resolve(`http://${ip}/`);
				else return reject();
			} catch {
				return reject();
			}
		});
	}
}