class VUtils {
    static makePublic() {
        if (VUtils.isUsed) {
            return;
        }
        moduleLoader.registerModule("VUtils")
        this.initHandlers();
        VUtils.isUsed = true;
        PrettyConsole.log("VUtils", "VUtils is now available in the Global Space! no VUtils. anymore needed");
        moduleLoader.finishModule("VUtils")
    }

    static initHandlers() {
        window.$ = this.$;
        window.$$ = this.$$;
        window.tryCatch = this.tryCatch;
        VUtils.nodePrototypes();
    }

    static $(selector, from) {
        from = from || document;
        return from.querySelector(selector);
    }

    static $$(selector, from) {
        from = from || document;
        return from.querySelectorAll(selector);
    }

    static tryCatch(data, callback, error) {
        data = VUtils.wrap(data, []);
        error = error || console.error;
        callback = callback || console.log;
        try {
            callback(...data);
        } catch (e) {
            error(e);
        }
    }

    static forEach(items, cb, error) {
        for (let i = 0; i < items.length; i++) {
            VUtils.tryCatch([items[i], i], cb, error);
        }
    }

    static get(valueOne, value) {
        return this.wrap(valueOne, value);
    }

    static mergeKeys(root, target) {
        root = root || {};
        let keys = Object.keys(root);
        for (let key of keys) {
            target[key] = root[key];
        }
        return target;
    }

    static mergeOptions(target, root) {
        root = root || {};
        let keys = Object.keys(root);
        for (let key of keys) {
            target[key] = VUtils.get(root[key], target[key]);
        }
        return target;
    }

    static wrap(valueOne, valueTwo) {
        let x = typeof valueTwo;
        if (!(valueOne instanceof Array) && valueTwo instanceof Array) {
            return [valueOne];
        }
        if (x === 'string' && valueOne instanceof Array) {
            return valueOne.join(".");
        }
        return valueOne === undefined ? valueTwo : valueOne;
    }

    static tempId() {
        return 'temp_' + Math.random().toString(36).substr(2, 16);
    }

    static hexToRgb(hex) {
        hex = hex.replace("#", "");
        let bigint = parseInt(hex, 16),
            r = (bigint >> 16) & 255,
            g = (bigint >> 8) & 255,
            b = bigint & 255;

        return [r / 255, g / 255, b / 255];
    }

    static nodePrototypes() {
        Node.prototype.find = function (selector) {
            return this.closest(selector);
        };
        Node.prototype.createNew = function (tag, options = {}) {
            let el = document.createElement(tag);
            if (options.classes) {
                el.classList.add(...VUtils.get(options.classes, []));
            }
            el.id = VUtils.get(options.id, '');
            el.innerHTML = VUtils.get(options.content, "");
            VUtils.mergeKeys(options.dataset, el.dataset);
            if (VUtils.get(options.append, true) === true) {
                this.appendChild(el);
            }

            return el;
        };
        Node.prototype.addDelegatedEventListener = function (type, aim, callback, err) {
            if (!callback || !type || !aim)
                return;
            this.addMultiListener(type, (event) => {
                let target = event.target;
                if (event.detail instanceof HTMLElement) {
                    target = event.detail;
                }
                if (target instanceof HTMLElement) {
                    if (target.matches(aim)) {
                        VUtils.tryCatch([event, target], callback, err);
                    } else {
                        const parent = target.find(aim);
                        if (parent) {
                            VUtils.tryCatch([event, parent], callback, err);
                        }
                    }
                }
            });
        };
        Node.prototype.addMultiListener = function (listener, cb, options = {}) {
            let splits = listener.split(" ");
            for (let split of splits) {
                this.addEventListener(split, cb, options);
            }
        };
        String.prototype.firstUpper = function () {
            return this.charAt(0).toUpperCase() + this.slice(1);
        };
        String.prototype.firstLower = function () {
            return this.charAt(0).toLowerCase() + this.slice(1);
        };
    }
}

VUtils.makePublic();