import { EventManager } from "./Events"
import * as Events from "./EventDefinitions"

export function extendJQueryStatic(): void {
    //Hilfsfunktion die den ersten Tab aktiviert der einen Fehler beinhaltet
    $.showErrorTab = () => {
        var found = false;
        if ($(".tab-content").find("div.tab-pane.active:has(div.has-error)").length === 0) {
            $(".tab-content").find("div.tab-pane:hidden:has(div.has-error)").each((index, tab) => {
                found = true;
                var id = $(<any>tab).attr("id");
                (<any>$("a[href=\"#" + id + "\"]")).tab("show");
            });
        }
        if (!found) {
            $(".tab-content").find("div.tab-pane:hidden:has(span.field-validation-error)").each((index, tab) => {
                found = true;
                var id = $(<any>tab).attr("id");
                (<any>$("a[href=\"#" + id + "\"]")).tab("show");
            });
        }
    }

    //Setzt Default-Werte für den unobtrusive Validator
    $.setupValidator = () => {
        $.validator.setDefaults({
            ignore: "input[type='hidden']:not('.validateAlways'), .dontValidate"
        });
    }

    /**
     * Buchen der Ajax-Fehler und allgemeins Handling!
     */
    $(document).ajaxError((e, xhr) => {
        var response;
        if (xhr.status === 401) {
            EventManager.getInstance().publish(Events.Common.unauthorized);
        }
        if (xhr.status === 402) {
            EventManager.getInstance().publish(Events.Common.subscriptionDenied);
        }
        if (xhr.status === 403) {
            EventManager.getInstance().publish(Events.Common.forbidden);
        }
        if (xhr.status === 451) {
            var target = xhr.getResponseHeader("Location");
            window.location = <any>target;
        }
    });

    /**
     * Markiert Modelstate Errors nachdem die View als Json-String geladen wurde
     * @param scrollToFirstError: soll zum ersten Fehler gescrollt werden?
     * @returns {} 
     */
    $.highlightErrors = (scrollToFirstError: boolean = true) => {
        $(".field-validation-error").each(function () {
            $(this).prev("input").addClass("is-invalid");
        });
        if (scrollToFirstError) {
            if ($(".is-invalid:visible:first").length > 0) {
                var top = $(".is-invalid:visible:first").offset().top;
                if (top > 200)
                    top -= 200;
                $("html,body").animate(<any>{
                    scrollTop: top
                }, 1000);
            }
        }
    }

    /**Nach ganz oben scrollen */
    $.scrollToTop = (speed: any = 1000) => {
        $("html,body").animate(<any>{
            scrollTop: 0
        }, speed);
    }

    /**
     * Reset eines forms
     * @returns {} 
     */
    $.resetForm = (formId: string = "") => {
        let tag = "form";
        if (formId.length > 0) {
            tag = formId;
        }
        $(tag).trigger("reset");
        $(tag).find("*").removeClass("is-valid");
        $(tag).find("*").removeClass("is-invalid");
        $(tag).find("*").removeClass("field-validation-valid");
        $(tag).find("*").removeClass("field-validation-error");
    }

    /**
     * Reinitialisiert den Forms und unobtrusive Validator.
     * Wichtig nachdem die View als Json-String geladen wurde
     * @returns {} 
     */
    $.reinitializeValidator = (formId: string = "") => {
        let tag = "form";
        if (formId.length > 0) {
            tag = formId;
        }
        if ($(tag).length > 0) {
            $(tag).removeData("validator");
            $.validator.unobtrusive.parse(tag);
        }
    }

    /**
     * Verhindern, dass die Browser Felder mit Autocomplete befüllen. Insbesondere bei ejautocomplete Feldern
     */
    $.randomAutocompleteValue = () => {
        var randomicAtomic = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
        $("input[type=text]").attr("autocomplete", randomicAtomic);
        $("input[type=email]").attr("autocomplete", randomicAtomic);
        $("input[type=password]").attr("autocomplete", randomicAtomic);
        $("form").each(() => {
            $(this).attr("autocomplete", "off");
        });
    }

    /**
     * Befüllt ein Formular basierend auf JSON Objekt
     * @param form
     * @param data
     */
    $.populateForm = (form: any, data: any) => {
        $.each(data, function (key, value) {

            if (value !== null && typeof value === "object") {
                this.populateForm(form, value);
            }
            else {
                var ctrl = $("[name=" + key.charAt(0).toUpperCase() + key.slice(1) + "]", form);
                switch (ctrl.prop("type")) {
                case "radio": case "checkbox":
                    ctrl.each(function () {
                        $(this).prop("checked", value);
                    });
                    break;
                    default:
                        if(typeof value === "number")
                            ctrl.val(Globalize.formatNumber(value));
                        else
                            ctrl.val(value);
                }
            }
        }.bind(this));
    }

    /**
     * Prüft ob ein Element existiert. So lange bis es existiert
     * @param selector
     */
    $.ensure = (selector:any) => {
        var promise = $.Deferred();
        var interval = setInterval(() => {
            if ($(selector)[0]) {
                clearInterval(interval);
                promise.resolve();
            }
        }, 1);
        return promise;
    };

    /**
     * Gibt an ob ein Element innerhalb des Sidebars angezeigt wird
     */
    $.fn.isInsideSidebar = function (): boolean {
        return $(this).parents("#sideBarRight").length === 1;
    }

    /**
     * Gibt an ob ein Element innerhalb des Modul Dialogs angezeigt wird
     */
    $.fn.isInsideModuleDialog = function (): boolean {
        return $(this).parents("#modalModuleContent").length === 1;
    }

    /**
     * Gibt den Suchtext zurück wenn diese mindestens [len] Zeichen lang ist.
     * @param len: wie lange muss der Suchtext mindestens sein
     * @returns {}: Suchtext
     */
    $.fn.valForSearch = function (len: number = 3): string {
        var searchText = $(this).val() as string;
        if (searchText.length < len) { searchText = ""; }
        return searchText;
    };

    /**
     * Gibt zurück ob eine Suche durchgeführt werden soll.
     * Das ist entweder wenn der Text mindestens [len] lang ist, oder aber 0 Zeichen lang (suche löschen)
     * @param len: wie lange muss der Suchtext mindestens sein
     * @returns {}: true wenn die Suche durchgeführt werden soll, false sonst
     */
    $.fn.doSearch = function (len: number = 3): boolean {
        var searchText = $(this).val() as string;
        if (searchText.length === 0) return true;
        if (searchText.length >= len) return true;
        return false;
    };

    /** Überschreiben der normalen remote validation. dies wird für Listen (editorfor) gemacht*/
    //$.validator.methods.oldRemote = $.validator.methods.remote;
    //$.validator.methods.remote = function (value, element, param, method) {
    //    if (this.optional(element)) {
    //        return "dependency-mismatch";
    //    }

    //    method = typeof method === "string" && method || "remote";

    //    var previous = this.previousValue(element, method),
    //        validator, data, optionDataString;

    //    if (!this.settings.messages[element.name]) {
    //        this.settings.messages[element.name] = {};
    //    }
    //    previous.originalMessage = previous.originalMessage || this.settings.messages[element.name][method];
    //    this.settings.messages[element.name][method] = previous.message;

    //    param = typeof param === "string" && { url: param } || param;
    //    optionDataString = $.param($.extend({ data: value }, param.data));
    //    if (previous.old === optionDataString) {
    //        return previous.valid;
    //    }

    //    previous.old = optionDataString;
    //    validator = this;
    //    this.startRequest(element);
    //    data = {};
    //    data[element.name.substr(element.name.lastIndexOf(".") + 1)] = value;
    //    $.ajax($.extend(true, {
    //        mode: "abort",
    //        port: "validate" + element.name,
    //        dataType: "json",
    //        data: data,
    //        context: validator.currentForm,
    //        success: function (response) {
    //            var valid = response === true || response === "true",
    //                errors, message, submitted;

    //            validator.settings.messages[element.name][method] = previous.originalMessage;
    //            if (valid) {
    //                submitted = validator.formSubmitted;
    //                validator.resetInternals();
    //                validator.toHide = validator.errorsFor(element);
    //                validator.formSubmitted = submitted;
    //                validator.successList.push(element);
    //                validator.invalid[element.name] = false;
    //                validator.showErrors();
    //            } else {
    //                errors = {};
    //                message = response || validator.defaultMessage(element, { method: method, parameters: value });
    //                errors[element.name] = previous.message = message;
    //                validator.invalid[element.name] = true;
    //                validator.showErrors(errors);
    //            }
    //            previous.valid = valid;
    //            validator.stopRequest(element, valid);
    //        }
    //    }, param));
    //    return "pending";
    //};

    $.validator.addMethod("requiredif", (value, element, params) => {
        const form = $(element).closest("form");
        const otherElement = $(form).find(`[name='${$(element).data("val-requiredif-other")}']`)[0];
        let isOtherSet = false;
        if (otherElement && $(otherElement).is(":checkbox")) {
            isOtherSet = $(otherElement).prop("checked").toString() === $(element).data("val-requiredif-otherval").toLowerCase();
        } else {
            isOtherSet = otherElement && $(otherElement).val().toString().toLowerCase() === $(element).data("val-requiredif-otherval").toString().toLowerCase();
        }
        if (isOtherSet && (value === undefined || value === null || value.length === 0))
            return false;
        return true;
    });

    $.validator.unobtrusive.adapters.add("requiredif", [], options => { 
        options.rules["requiredif"] = {};
        options.messages["requiredif"] = options.message;
    });

    $.validator.addMethod("requiredif-defaultlangauge", (value, element, params) => {
        const form = $(element).closest("form");
        const otherElement = $(form).find(`[name='${$(element).data("val-requiredif-defaultlangauge-other")}']`)[0];
        let isOtherSet = false;
        isOtherSet = otherElement && $(otherElement).val().toString().toLowerCase() === $(element).data("val-requiredif-defaultlangauge-otherval").toString().toLowerCase();
        if (isOtherSet && (value === undefined || value === null || value.length === 0))
            return false;
        return true;
    });

    $.validator.unobtrusive.adapters.add("requiredif-defaultlangauge", [], options => { 
        options.rules["requiredif-defaultlangauge"] = {};
        options.messages["requiredif-defaultlangauge"] = options.message;
    });


    /**
     * Serialisiert ein Form
     * @param filter: Optionaler NOT! Filter zum Einschränken der Felder. z.B.: "[id$=_hidden]"
     * @param includeDisabled: Sollen elemente mit disabled inkludiert werden
     */
    $.fn.serializeWithFilter = function (filter: string = "", includeDisabled: boolean = false): string {
        var form;
        if (includeDisabled) {
            let result: string;
            var inputs = $(this).find(":disabled");
            inputs.prop("disabled", false);
            if (filter.length > 0) {
                form = <any>$(this)[0];
                result = $(form.elements).not(filter).serialize();
            } else {
                result = $(this).serialize();
            }
            inputs.prop("disabled", true);
            return result;
        } else {
            if (filter.length > 0) {
                form = <any>$(this)[0];
                return $(form.elements).not(filter).serialize();
            } else {
                return $(this).serialize();
            }
        }
    }

    //$.validator.unobtrusive.adapters.add("requiredif", ["other", "otherval"], options => {
    //    var value = {
    //        depends() {
    //            var element = $(options.form).find(`[name='${options.params.other}']`)[0];
    //            if (element && $(element).is(":checkbox")) {
    //                return $(element).prop("checked").toString() === options.params.otherval.toLowerCase();
    //            }
    //            return element && $(element).val().toString().toLowerCase() === options.params.otherval.toLowerCase();
    //        }
    //    }
    //    options.rules["requiredif"] = { };
    //    options.messages["requiredif"] = options.message;
    //});
}