import PowerduckState from '../app/powerduck-state';
import { PortalUtils } from './utils/utils';

export class QueryStringUtils {
	static getBool(paramName: string, defaultValue?: boolean): boolean {
		return this._parseQsBool(this._getQsValueCaseInsensitive(paramName), defaultValue);
	}

	static getString(paramName: string, defaultValue?: string): string {
		return this._getQsValueCaseInsensitive(paramName) || defaultValue;
	}

	static getNumber(paramName: string, defaultValue?: number): number {
		const val = this._getQsValueCaseInsensitive(paramName);
		if (val && PortalUtils.isNumber(val)) {
			return Number(val);
		} else {
			return defaultValue;
		}
	}

	private static _getQsValueCaseInsensitive(paramName: string): string {
		paramName = paramName.toLowerCase();
		const route = PowerduckState.getCurrentRouteQuery();

		if (route != null && route.value.query != null) {
			for (const key in route.value.query) {
				if (key.toLowerCase() == paramName) {
					return route.value.query[key] as any;
				}
			}
		}

		const qs = location.search;
		if (qs != null && qs.length > 0) {
			const splitArr = qs.substring(1).split('&');
			for (let i = 0, len = splitArr.length; i < len; i++) {
				const pair = splitArr[i];
				if (pair.toLowerCase().indexOf(`${paramName}=`) == 0) {
					return decodeURIComponent(pair.substring(paramName.length + 1));
				}
			}
		}

		return null;
	}

	static getAll(paramName: string): string[] {
		const normalized = paramName.toLowerCase();
		const values: string[] = [];
		const route = PowerduckState.getCurrentRouteQuery();
		const routeQuery = route?.value?.query ?? {};

		for (const [
			key,
			value,
		] of Object.entries(routeQuery)) {
			if (key.toLowerCase() === normalized) {
				if (Array.isArray(value)) {
					values.push(...value.map(v => `${v}`));
				} else if (value != null) {
					values.push(`${value}`);
				}
			}
		}

		if (typeof location?.search === 'string' && location.search.length > 1) {
			const params = new URLSearchParams(location.search);
			for (const [
				key,
				value,
			] of params.entries()) {
				if (key.toLowerCase() === normalized) {
					values.push(value);
				}
			}
		}

		return values;
	}

	static setValues(paramName: string, values: (string | number)[]): void {
		const router = (PowerduckState as any).getRouter?.();
		const route = router?.currentRoute?.value;

		if (router && route) {
			const nextQuery = { ...(route.query || {}) };
			if (values?.length) {
				nextQuery[paramName] = values.map(v => `${v}`);
			} else {
				delete nextQuery[paramName];
			}

			router.replace({ ...route, query: nextQuery });
			return;
		}

		if (typeof window !== 'undefined') {
			const url = new URL(window.location.href);
			url.searchParams.delete(paramName);
			values?.forEach(v => url.searchParams.append(paramName, `${v}`));
			window.history.replaceState(
				{},
				document.title,
				url.toString(),
			);
		}
	}

	static removeValue(paramName: string, valueToRemove: string | number): void {
		const nextValues = this.getAll(paramName).filter(v => v !== `${valueToRemove}`);
		this.setValues(paramName, nextValues);
	}

	private static _parseQsBool(qsArg: string, defaultValue?: boolean): boolean {
		if (qsArg == null || qsArg.length == 0) {
			if (defaultValue != null) {
				return defaultValue;
			} else {
				return false;
			}
		}

		qsArg = qsArg.toLowerCase().trim();
		return qsArg == '1' || qsArg == 'yes' || qsArg == 'true';
	}
}