/*!
 * theia sticky sidebar v1.7.0
 * https://github.com/wecodepixels/theia-sticky-sidebar
 *
 * glues your website's sidebars, making them permanently visible while scrolling.
 *
 * copyright 2013-2016 wecodepixels and other contributors
 * released under the mit license
 */

(function ($) {
    $.fn.theiastickysidebar = function (options) {
        var defaults = {
            'containerselector': '',
            'additionalmargintop': 0,
            'additionalmarginbottom': 0,
            'updatesidebarheight': true,
            'minwidth': 0,
            'disableonresponsivelayouts': true,
            'sidebarbehavior': 'modern',
            'defaultposition': 'relative',
            'namespace': 'tss'
        };
        options = $.extend(defaults, options);

        // validate options
        options.additionalmargintop = parseint(options.additionalmargintop) || 0;
        options.additionalmarginbottom = parseint(options.additionalmarginbottom) || 0;

        tryinitorhookintoevents(options, this);

        // try doing init, otherwise hook into window.resize and document.scroll and try again then.
        function tryinitorhookintoevents(options, $that) {
            var success = tryinit(options, $that);

            if (!success) {
                console.log('tss: body width smaller than options.minwidth. init is delayed.');

                $(document).on('scroll.' + options.namespace, function (options, $that) {
                    return function (evt) {
                        var success = tryinit(options, $that);

                        if (success) {
                            $(this).unbind(evt);
                        }
                    };
                }(options, $that));
                $(window).on('resize.' + options.namespace, function (options, $that) {
                    return function (evt) {
                        var success = tryinit(options, $that);

                        if (success) {
                            $(this).unbind(evt);
                        }
                    };
                }(options, $that))
            }
        }

        // try doing init if proper conditions are met.
        function tryinit(options, $that) {
            if (options.initialized === true) {
                return true;
            }

            if ($('body').width() < options.minwidth) {
                return false;
            }

            init(options, $that);

            return true;
        }

        // init the sticky sidebar(s).
        function init(options, $that) {
            options.initialized = true;

            // add css
            var existingstylesheet = $('#theia-sticky-sidebar-stylesheet-' + options.namespace);
            if (existingstylesheet.length === 0) {
                $('head').append($('<style id="theia-sticky-sidebar-stylesheet-' + options.namespace + '">.theiastickysidebar:after {content: ""; display: table; clear: both;}</style>'));
            }

            $that.each(function () {
                var o = {};

                o.sidebar = $(this);

                // save options
                o.options = options || {};

                // get container
                o.container = $(o.options.containerselector);
                if (o.container.length == 0) {
                    o.container = o.sidebar.parent();
                }

                // create sticky sidebar
                o.sidebar.parents().css('-webkit-transform', 'none'); // fix for webkit bug - https://code.google.com/p/chromium/issues/detail?id=20574
                o.sidebar.css({
                    'position': o.options.defaultposition,
                    'overflow': 'visible',
                    // the "box-sizing" must be set to "content-box" because we set a fixed height to this element when the sticky sidebar has a fixed position.
                    '-webkit-box-sizing': 'border-box',
                    '-moz-box-sizing': 'border-box',
                    'box-sizing': 'border-box'
                });

                // get the sticky sidebar element. if none has been found, then create one.
                o.stickysidebar = o.sidebar.find('.theiastickysidebar');
                if (o.stickysidebar.length == 0) {
                    // remove <script> tags, otherwise they will be run again when added to the stickysidebar.
                    var javascriptmimetypes = /(?:text|application)\/(?:x-)?(?:javascript|ecmascript)/i;
                    o.sidebar.find('script').filter(function (index, script) {
                        return script.type.length === 0 || script.type.match(javascriptmimetypes);
                    }).remove();

                    o.stickysidebar = $('<div>').addclass('theiastickysidebar').append(o.sidebar.children());
                    o.sidebar.append(o.stickysidebar);
                }

                // get existing top and bottom margins and paddings
                o.marginbottom = parseint(o.sidebar.css('margin-bottom'));
                o.paddingtop = parseint(o.sidebar.css('padding-top'));
                o.paddingbottom = parseint(o.sidebar.css('padding-bottom'));

                // add a temporary padding rule to check for collapsable margins.
                var collapsedtopheight = o.stickysidebar.offset().top;
                var collapsedbottomheight = o.stickysidebar.outerheight();
                o.stickysidebar.css('padding-top', 1);
                o.stickysidebar.css('padding-bottom', 1);
                collapsedtopheight -= o.stickysidebar.offset().top;
                collapsedbottomheight = o.stickysidebar.outerheight() - collapsedbottomheight - collapsedtopheight;
                if (collapsedtopheight == 0) {
                    o.stickysidebar.css('padding-top', 0);
                    o.stickysidebarpaddingtop = 0;
                }
                else {
                    o.stickysidebarpaddingtop = 1;
                }

                if (collapsedbottomheight == 0) {
                    o.stickysidebar.css('padding-bottom', 0);
                    o.stickysidebarpaddingbottom = 0;
                }
                else {
                    o.stickysidebarpaddingbottom = 1;
                }

                // we use this to know whether the user is scrolling up or down.
                o.previousscrolltop = null;

                // scroll top (value) when the sidebar has fixed position.
                o.fixedscrolltop = 0;

                // set sidebar to default values.
                resetsidebar();

                o.onscroll = function (o) {
                    // stop if the sidebar isn't visible.
                    if (!o.stickysidebar.is(":visible")) {
                        return;
                    }

                    // stop if the window is too small.
                    if ($('body').width() < o.options.minwidth) {
                        resetsidebar();
                        return;
                    }

                    // stop if the sidebar width is larger than the container width (e.g. the theme is responsive and the sidebar is now below the content)
                    if (o.options.disableonresponsivelayouts) {
                        var sidebarwidth = o.sidebar.outerwidth(o.sidebar.css('float') == 'none');

                        if (sidebarwidth + 50 > o.container.width()) {
                            resetsidebar();
                            return;
                        }
                    }

                    var scrolltop = $(document).scrolltop();
                    var position = 'static';

                    // if the user has scrolled down enough for the sidebar to be clipped at the top, then we can consider changing its position.
                    if (scrolltop >= o.sidebar.offset().top + (o.paddingtop - o.options.additionalmargintop)) {
                        // the top and bottom offsets, used in various calculations.
                        var offsettop = o.paddingtop + options.additionalmargintop;
                        var offsetbottom = o.paddingbottom + o.marginbottom + options.additionalmarginbottom;

                        // all top and bottom positions are relative to the window, not to the parent elemnts.
                        var containertop = o.sidebar.offset().top;
                        var containerbottom = o.sidebar.offset().top + getclearedheight(o.container);

                        // the top and bottom offsets relative to the window screen top (zero) and bottom (window height).
                        var windowoffsettop = 0 + options.additionalmargintop;
                        var windowoffsetbottom;

                        var sidebarsmallerthanwindow = (o.stickysidebar.outerheight() + offsettop + offsetbottom) < $(window).height();
                        if (sidebarsmallerthanwindow) {
                            windowoffsetbottom = windowoffsettop + o.stickysidebar.outerheight();
                        }
                        else {
                            windowoffsetbottom = $(window).height() - o.marginbottom - o.paddingbottom - options.additionalmarginbottom;
                        }

                        var staticlimittop = containertop - scrolltop + o.paddingtop;
                        var staticlimitbottom = containerbottom - scrolltop - o.paddingbottom - o.marginbottom;

                        var top = o.stickysidebar.offset().top - scrolltop;
                        var scrolltopdiff = o.previousscrolltop - scrolltop;

                        // if the sidebar position is fixed, then it won't move up or down by itself. so, we manually adjust the top coordinate.
                        if (o.stickysidebar.css('position') == 'fixed') {
                            if (o.options.sidebarbehavior == 'modern') {
                                top += scrolltopdiff;
                            }
                        }

                        if (o.options.sidebarbehavior == 'stick-to-top') {
                            top = options.additionalmargintop;
                        }

                        if (o.options.sidebarbehavior == 'stick-to-bottom') {
                            top = windowoffsetbottom - o.stickysidebar.outerheight();
                        }

                        if (scrolltopdiff > 0) { // if the user is scrolling up.
                            top = math.min(top, windowoffsettop);
                        }
                        else { // if the user is scrolling down.
                            top = math.max(top, windowoffsetbottom - o.stickysidebar.outerheight());
                        }

                        top = math.max(top, staticlimittop);

                        top = math.min(top, staticlimitbottom - o.stickysidebar.outerheight());

                        // if the sidebar is the same height as the container, we won't use fixed positioning.
                        var sidebarsameheightascontainer = o.container.height() == o.stickysidebar.outerheight();

                        if (!sidebarsameheightascontainer && top == windowoffsettop) {
                            position = 'fixed';
                        }
                        else if (!sidebarsameheightascontainer && top == windowoffsetbottom - o.stickysidebar.outerheight()) {
                            position = 'fixed';
                        }
                        else if (scrolltop + top - o.sidebar.offset().top - o.paddingtop <= options.additionalmargintop) {
                            // stuck to the top of the page. no special behavior.
                            position = 'static';
                        }
                        else {
                            // stuck to the bottom of the page.
                            position = 'absolute';
                        }
                    }

                    /*
                     * performance notice: it's ok to set these css values at each resize/scroll, even if they don't change.
                     * it's way slower to first check if the values have changed.
                     */
                    if (position == 'fixed') {
                        var scrollleft = $(document).scrollleft();

                        o.stickysidebar.css({
                            'position': 'fixed',
                            'width': getwidthforobject(o.stickysidebar) + 'px',
                            'transform': 'translatey(' + top + 'px)',
                            'left': (o.sidebar.offset().left + parseint(o.sidebar.css('padding-left')) - scrollleft) + 'px',
                            'top': '0px'
                        });
                    }
                    else if (position == 'absolute') {
                        var css = {};

                        if (o.stickysidebar.css('position') != 'absolute') {
                            css.position = 'absolute';
                            css.transform = 'translatey(' + (scrolltop + top - o.sidebar.offset().top - o.stickysidebarpaddingtop - o.stickysidebarpaddingbottom) + 'px)';
                            css.top = '0px';
                        }

                        css.width = getwidthforobject(o.stickysidebar) + 'px';
                        css.left = '';

                        o.stickysidebar.css(css);
                    }
                    else if (position == 'static') {
                        resetsidebar();
                    }

                    if (position != 'static') {
                        if (o.options.updatesidebarheight == true) {
                            o.sidebar.css({
                                'min-height': o.stickysidebar.outerheight() + o.stickysidebar.offset().top - o.sidebar.offset().top + o.paddingbottom
                            });
                        }
                    }

                    o.previousscrolltop = scrolltop;
                };

                // initialize the sidebar's position.
                o.onscroll(o);

                // recalculate the sidebar's position on every scroll and resize.
                $(document).on('scroll.' + o.options.namespace, function (o) {
                    return function () {
                        o.onscroll(o);
                    };
                }(o));
                $(window).on('resize.' + o.options.namespace, function (o) {
                    return function () {
                        o.stickysidebar.css({'position': 'static'});
                        o.onscroll(o);
                    };
                }(o));

                // recalculate the sidebar's position every time the sidebar changes its size.
                if (typeof resizesensor !== 'undefined') {
                    new resizesensor(o.stickysidebar[0], function (o) {
                        return function () {
                            o.onscroll(o);
                        };
                    }(o));
                }

                // reset the sidebar to its default state
                function resetsidebar() {
                    o.fixedscrolltop = 0;
                    o.sidebar.css({
                        'min-height': '1px'
                    });
                    o.stickysidebar.css({
                        'position': 'static',
                        'width': '',
                        'transform': 'none'
                    });
                }

                // get the height of a div as if its floated children were cleared. note that this function fails if the floats are more than one level deep.
                function getclearedheight(e) {
                    var height = e.height();

                    e.children().each(function () {
                        height = math.max(height, $(this).height());
                    });

                    return height;
                }
            });
        }

        function getwidthforobject(object) {
            var width;

            try {
                width = object[0].getboundingclientrect().width;
            }
            catch (err) {
            }

            if (typeof width === "undefined") {
                width = object.width();
            }

            return width;
        }

        return this;
    }
})(jquery);