/// <reference path="../_references.js" />
/// prointernet Helpers
/// Version: 1.8.6166.30335

// Form AsyncSubmit
$.fn.submitAsync = function (config) {
    var form = $(this);

    config = $.extend({
        data: [],
        editContainer: ".edit",
        confirmContainer: ".confirm",
        source: form.attr("id"),
        autoInfo: true,
        validate: true,
        valid: false,
        infoTarget: form
    }, config);

    // Form daten und manuelle config.daten zusammenführen
    config.data = config.data.concat(form.serializeArray());

    if (config.source) {
        config.data.push({ name: "source", value: config.source.replace("form", "") });
    }

    if (config.validate) {
        config.valid = form.groupValid();
    } else {
        config.valid = true;
    }

    // Form absenden und Result callback
    var formUrl = form.attr("action");
    if (config.valid) {
        $.post(formUrl, config.data, function (result) {
            config.result = result;

            // Callback
            if (config.callback) {
                config.callback(config);
            }

            // Container für Edit & Confirm toggeln
            if ($(config.confirmContainer).length > 0 && result.success) {
                $(config.confirmContainer).show();
                $(config.editContainer).hide();

                $(config.confirmContainer + " .message").html(result.message);
            } else {
                // Automatischer Validation Error mit result.message
                if (config.autoInfo && result.message) {
                    var targetId = (result.targetId && result.targetId != "" ? result.targetId : form.attr("id"));

                    var validatorConfig = {};
                    validatorConfig[result.targetId] = result.message;
                    form.validate().showErrors(validatorConfig);
                }
            }

            // Live
            AjaxNav.live();
        }).error(function (e) {
            $.showError(e.responseText);
        });
    }
}

// Validation von Gruppen
$.fn.groupValid = function () {
    var groupIsValid = true;
    var infoVisible = false;
    this.each(function () {
        $(this).find("input:visible,select:visible,textarea:visible").not(".rtChk").each(function () {
            var element = $(this);
            if (!element.valid()) {
                groupIsValid = false;

                // Scroll zum ersten Fehler
                if (!infoVisible) {
                    if (element.offset().top > 0) {
                        document.scrollActive = true;
                        var offTop = element.offset().top - 300;
                        $("html,body").animate({ scrollTop: offTop });
                        element.focus();
                    }
                    infoVisible = true;
                }
            }
        });
    });
    return groupIsValid;
}

// Tooltip
$.fn.toolTip = function (config) {

    config = $.extend({
        type: "standard",
        html: "",
        id: (new Date).getTime(),
        contentId: "",
        delay: 3000,
        wait: 0,
        cssclass: "",
        alignTo: "",
        left: 0,
        closeable: false,
        width: 0,
        top: 0,
        position: "bottom"
    }, config);

    var tipOpen = false;

    // Prüfung ob Opener aktiven Tip hat
    if (config.opener) {
        if (!config.opener.hasClass("tipopen")) {
            config.opener.addClass("tipopen");
        } else {
            tipOpen = true;
        }
    }

    if (!tipOpen) {
        var c = $(this);
        c.addClass("infoActive");

        // Tip erstellen
        var cLayer = $("<div id='infotip" + config.id + "' class='infotip " + config.cssclass + "' style='display:none;'><div class='frame'><div class='arrow'></div><div class='cnt'></div></div></div>").appendTo($("#master"));
        var cCnt = cLayer.find(".cnt");

        // Content Element
        if (config.contentId != "") {
            config.contentElement = $("#" + config.contentId);
            config.contentElement.attr("activeTip", config.id)
            config.contentElementParent = config.contentElement.parent();
            cCnt.append(config.contentElement.show());
            config.width = config.contentElement.width();

            // HTML
        } else {
            cCnt.html(config.html);
        }

        // Position übeschreibungen
        if (config.top > 0) {
            cLayer.css({ "margin-top": config.top + "px" });
        }
        if (config.left > 0) {
            cLayer.css({ "margin-left": config.left + "px" });
        }
        if (config.width > 0) {
            cLayer.css({ "width": config.width + "px" });
        }

        // Align an Objekt (offset left + top)
        var alignObj = c;
        if (config.alignTo) {
            alignObj = $(config.alignTo);
            config.alignTo.addClass("active");
        }

        // Layer auf Inputcontrol
        if (c[0].tagName == "INPUT") {
            if (!c.is(":text")) {
                // Wenn kein Textelement z.B. Checkbox oder Radiobutton dann Layer in Parentelement platzieren
                alignObj = alignObj.parent();
            }

            // Input aktiv setzen
            c.addClass("active");
            c.focus(function () {
                hideLayer();
            });
        }

        // Closable
        if (config.closable) {
            config.delay = 0;
            $("#masterpage").click(function (e) {
                if (e.target.id != config.opener.attr("id")) {
                    hideLayer();
                }
            });
        }

        cLayer.css({ "left": (alignObj.offset().left + alignObj.width() + 40) + "px" });
        cLayer.css({ "top": (alignObj.offset().top + (config.position == "bottom" ? alignObj.height() : 0)) + "px" });

        // Layer ausblenden
        var hideLayer = function () {
            cLayer.fadeOut(500, function () {
                c.removeClass("infoActive");
                c.removeClass("active");
                if (config.callback) {
                    config.callback();
                }
                if (config.alignTo) {
                    config.alignTo.removeClass("active");
                    config.alignTo.parent().removeClass("active");
                }

                // Contentelement zurück an Ursprungsposition setzen
                if (config.contentElement) {
                    config.contentElementParent.append(config.contentElement.hide());
                }

                if (config.opener) {
                    config.opener.removeClass("tipopen");
                }

                // Layer remove
                cLayer.remove();
            });
        }
        c.hideLayer = hideLayer;

        // Vorhandene aktive Layer ausblenden
        $(".infotip").fadeOut(200);

        // Bildschirmbreite überprüfen
        var overflow = alignObj.offset().left + cLayer.width();
        if (overflow > $(window).width()) {
            cLayer.addClass("leftalign");
            cLayer.css({ "left": (alignObj.offset().left - cLayer.width() + 20) + "px" });
        }

        // Layer einblenden
        cLayer.delay(config.wait).fadeIn(500, function () {
            if (config.delay > 0) {
                setTimeout(function () {
                    hideLayer();
                }, config.delay);
            }
        });
    }

    return c;
}

// Overlay
$.fn.overlay = function (config) {
    config = $.extend({
        opacity: 0.6,
        fadeInSpeed: 200,
        fadeOutSpeed: 200
    }, config);

    return {
        getLayer: function () {
            var layer = $("#overlay");
            if (layer.length == 0) {
                layer = $("<div id='overlay' style='display:none;'></div>").appendTo($("body"));
            }
            return layer;
        },
        show: function (showConfig) {
            var o = this;
            var layer = this.getLayer();
            if (!layer.is(":visible")) {
                layer.css({ opacity: 0 }).show().animate({ opacity: config.opacity }, config.fadeInSpeed, function () {
                    if (showConfig.callback) showConfig.callback();
                    if (showConfig.click) {
                        layer.click(function () {
                            showConfig.click();
                        });
                    }

                    // Scrolling auf #Master deaktivieren
                    //$("#contentframe").css({ "position": "fixed" });
                });
            }
        },
        hide: function (callback) {
            var layer = this.getLayer();
            layer.animate({ opacity: 0 }, config.fadeOutSpeed, function () {
                if (callback) callback();
                layer.remove();

                // Scrolling auf #Master deaktivieren
                //$("#contentframe").css({ "position": "relative" });
            });
        }
    }
}

// Layer
$.fn.showLayer = function (config) {

    config = $.extend({
        url: "",
        width: 0,
        height: 0,
        iframe: false,
        cssClass: "",
        id: "",
        closeLink: true,
        fadeInSpeed: 200,
        fadeOutSpeed: 100,
        closeLinkText: "<span>Fenster schließen</span>",
        backLink: false,
        backLinkText: "zurück zur Übersicht",
        top: 60,
        bottom: 60,
        padding: 80,
        overlay: true,
        center: false,
        resize: false
    }, config);

    // ID festlegen
    if (config.id == "") {
        if (config.opener) {
            if (config.opener.attr("lid")) {
                config.id = "sLayer" + config.opener.attr("lid");
            } else if (config.opener.attr("id")) {
                config.id = "sLayer" + config.opener.attr("id").replace(/_/g, "");
            }

            if (config.opener.hasClass("full")) {
                config.width = $("#contentframe").width();
            }
        }
        if (config.opener == "") {
            config.id = "sLayer" + (new Date).getTime();
        }
    } else {
        config.id = "sLayer" + config.id;
    }

    // Container anzeigen wenn URL übergeben oder DIV Zuordnung
    var container = $(this);
    if (config.url != "" || container.length > 0) {

        // Hashwert parsen
        var hash = config.url.match(/#.+/);
        if (hash) {
            hash = $.deparam.fragment(hash[0]);
        }
        config.url = config.url.replace(/#.+/, "");

        // Layer erstellen
        var layer = $("#" + config.id);
        if (layer.length == 0) {
            layer = $("<div id='" + config.id + "' class='layer " + config.cssClass + "' style='display:none;'>" +
                      "<div class='lcnt'></div>" +
                      "</div>").appendTo($("body"));
            //layer.shadow();
        }
        var lCnt = layer.find(".lcnt");

        // CSS Anpassungen
        layer.css({ "z-index": 550 + $(".layer:visible").length });

        // Layer Proportion anpassen
        layer.validateSize = function (callback) {
            layer.css({ "top": $(window).scrollTop() + config.top + "px" });
            if (callback) callback();
        }

        // Show
        layer.showLayer = function () {

            // Opener aktiv schalten
            if (config.opener) {
                config.opener.addClass("active");
                if (layer.data("lastOpener")) layer.data("lastOpener").removeClass("active");
                layer.data("lastOpener", config.opener);
            }

            // Close
            if (config.closeLink) {
                $("<a href='javascript:;' class='close closeLayer'>" + config.closeLinkText + "</a>").appendTo(layer);
            }
            layer.close = function () {
                layer.fadeOut(config.fadeOutSpeed, function () {
                    // Opener inaktiv schalten
                    if (config.opener) config.opener.removeClass("active");

                    // Callback
                    if (config.closeCallback) config.closeCallback();

                    // Overlay ausblenden
                    $.fn.overlay().hide();

                    // Layer entfernen
                    layer.remove();
                });
            }

            // Zurück Link
            if (config.backLink || (config.opener ? config.opener.hasClass("backLink") : false)) {
                if (layer.find(".back").length == 0) {
                    $("<a href='javascript:;' class='back s1 closeLayer'>" + config.backLinkText + "</a>").appendTo(layer);
                }
            }
            layer.find("a.closeLayer").click(function (e) {
                layer.close();
                e.preventDefault();
                return false;
            });

            // Overlay
            layer.validateSize(function () {
                if (config.overlay) {
                    $.fn.overlay().show({
                        callback: function () { layer.fadeIn(config.fadeInSpeed); },
                        click: function () { layer.close(); }
                    });

                    // Kein Overlay
                } else {
                    layer.fadeIn(config.fadeInSpeed);
                }
            });

        }

        // Layerinhalt async laden
        layer.update = function (c) {
            if (c.iframe) {
                // Iframe
                var iframe = $("#layerIframe");
                if (iframe.length == 0) {
                    iframe = $("<iframe id='layerIframe'></iframe>").appendTo(lCnt);
                }
                iframe.attr("src", c.url);
            } else {

                // Static
                $.get(c.url, {
                    type: "ajax",
                    renderid: c.render
                }, function (html) {
                    lCnt.html(html);
                    AjaxNav.live();
                    layer.showLayer();

                    // Google Analytics
                    if (typeof _gaq != "undefined") _gaq.push(["_trackPageview", c.url]);

                }).error(function (e) {
                    $.showError(e.responseText);
                });
            }
        }

        if (config.url != "") {
            layer.update(config);

            // Layer nur einblenden
        } else {
            lCnt.append(container.show());
            layer.showLayer();
        }

        return layer;
    }
}

// HTML async laden und xhead verarbeiten
$.getX = function (url, data, callback, type) {
    $.get(url, data, function (result) {

        // XHead Div erstellen wenn nicht vorhanden
        var xHead = $("#xhead");
        if (xHead.length == 0) {
            xHead = $("<div id='xhead' style='display:none;'></div>").appendTo($("body"));
        } else {
            xHead.empty();
        }

        // XHead mit RegEx parsen und ausführen
        var regExHead = /<div id="xhead".+?>([\s\S]*?)<\/div>/;
        var matchHead = regExHead.exec(result);
        xHead.html(matchHead[1]);

        // Ausgabe XHTML
        callback(result);
    }, type);
}

// URL Vars
$.extend({
    getUrlVars: function () {
        var vars = [], hash;
        var hashes = window.location.href.slice(window.location.href.indexOf('?') + 1).split('&');
        for (var i = 0; i < hashes.length; i++) {
            hash = hashes[i].split('=');
            vars.push(hash[0]);
            vars[hash[0]] = hash[1];
        }
        return vars;
    },
    getUrlVar: function (name) {
        return $.getUrlVars()[name];
    },
    getHashVars: function () {
        var vars = [], hash;
        var hashes = window.location.href.slice(window.location.href.indexOf('#') + 1).split('&');
        for (var i = 0; i < hashes.length; i++) {
            hash = hashes[i].split('=');
            vars.push(hash[0]);
            vars[hash[0]] = hash[1];
        }
        return vars;
    },
    getHashVar: function (name) {
        return $.getHashVars()[name];
    }
});

$.fn.isScrollingVisible = function () {
    var target = $(this);
    var itemTop = target.offset().top;
    var scrollTop = $(window).scrollTop();

    var xMin = scrollTop;
    var xMax = scrollTop + $(window).height();

    if (itemTop < xMin || itemTop > xMax) {
        return false;
    }
    return true;
}

$.fn.scrollToWhenNotVisible = function (callback) {
    var target = $(this);
    if (!target.isScrollingVisible()) {
        console.log("scrol?", target)
        var itemTop = target.offset().top;
        var animationTime = AjaxNav.scrollAnimationTime || 250;
        if (AjaxNav.preventScrollAnimation) {
            animationTime = 0;
        }
        //$("html,body").delay(AjaxNav.scrollTopDelay || 0).animate({ scrollTop: itemTop - 50 }, animationTime, function () {
        //    if (callback) callback();
        //});



    } else {
        if (callback) callback();
    }

}


// Set Cookie
function setCookie(cname, cvalue, exdays) {
    var d = new Date();
    d.setTime(d.getTime() + (exdays * 24 * 60 * 60 * 1000));
    var expires = "expires=" + d.toGMTString();
    document.cookie = cname + "=" + cvalue + "; " + expires;
}

// Get Cookie
function getCookie(cname) {
    var name = cname + "=";
    var ca = document.cookie.split(';');
    for (var i = 0; i < ca.length; i++) {
        var c = ca[i];
        while (c.charAt(0) == ' ') c = c.substring(1);
        if (c.indexOf(name) == 0) {
            return c.substring(name.length, c.length);
        }
    }
    return "";
}

// Default Button
if (!document.defaultButtonsParsed) {
    $(function () {
        $(document).on("keypress", "[data-default-btn]", function (e) {
            var form = $(this);
            if (e.which == 13) {
                var btn = $("#" + form.attr("data-default-btn"));
                btn.click();
            }
        });
    });
    document.defaultButtonsParsed = true;
}

// Console Log Fallback <= IE8
if (typeof (console) == "undefined") {
    console = {
        log: function (e) { }
    }
}

// UpdatePanel Validation
$(document).ready(function () {

    AjaxNav.live("webForms", function () {

        if (typeof (Sys) != 'undefined' && document.lastWebFormUrl != location.href) {

            $(document).ready(function () {

                // UpdatePanel Request Validation
                var prm = Sys.WebForms.PageRequestManager.getInstance();
                if (prm != null) {
                    prm.add_initializeRequest(function (sender, e) {

                        document.validator = $("form").validate({
                            highlight: function (element) {
                                // Scroll zu erstem ungültigen Feld
                                if ($(".has-error").length == 0) {
                                    $(element).focusInvalid();
                                }
                                $(element).closest('.form-group').addClass('has-error');
                            },
                            unhighlight: function (element) {
                                $(element).closest('.form-group').removeClass('has-error');
                            },
                            errorElement: 'span',
                            errorClass: 'help-block',
                            errorPlacement: function (error, element) {
                                if (element.parent('.checkbox, .checkbox-inline, .radio, .radio-inline').length) {
                                    error.insertAfter(element.parent().parent());
                                } else if (element.parent('.form-group, .btn').length) {
                                    error.insertAfter(element);
                                } else {
                                    error.insertAfter(element);
                                }
                            }
                        });

                        var button = $(e._postBackElement);

                        // Wenn Button Attribut [val-group] angegeben hat nur Inputs mit dieser val-group validieren
                        var validationGroup = (button.attr("data-valgroup") ? button.attr("data-valgroup") : "all");

                        // Loop durch UpdatePanels
                        var formInvalid = false;
                        $.each(e._updatePanelsToUpdate, function (idx, panelName) {
                            var updatePanel = $("[id*='" + panelName.replace("$", "_") + "']");
                            updatePanel.find("input,select,textarea").each(function () {
                                var input = $(this);

                                // Nur Inputs für aktuelle ValidationGroup validieren
                                if (validationGroup != "all") {
                                    if (input.attr("data-valgroup") != validationGroup) {
                                        return false;
                                    }
                                }

                                // Input valid?
                                if (!document.validator.element(input)) {
                                    formInvalid = true;
                                }
                            });
                        });

                        // Form blockieren und zu erstem Element scrollen
                        if (formInvalid) {
                            e.set_cancel(true);
                            $(".has-error").first().focusInvalid();
                        }

                    });
                }
            });

            document.lastWebFormUrl = location.href;
        }

    });

});

// jQuery Validation Invalid Field Focus
$.fn.focusInvalid = function () {
    var element = $(this);
    if (element.length > 0) {
        var scrollOffset = element.offset().top - ($(window).height() * 0.5);
        $("html,body").animate({ scrollTop: scrollOffset }, function () {
            element.focus();
        });
    }
    return element;
}