(function ($) {

    $.extend({ pwTyper: {

        wrap: function (s) {

            // remove legacy span.pwtext elements			
            s = s.replace(/(<span[^>]*?class="[^"]*pwText[^"]*>)([^<]*)(<\/span>)/g, '$2');

            // wraps all text nodes in a span.pwtext element 
            s = s.replace(/(>|^(?!<))([^<]+)(<|(?!>)$)/g, '$1<span class="pwText">$2</span>$3');

            // groups special characters such as &amp; into a span.pwSpecial element
            // only match special characters within existing .pwText elements (not in attributes)
            s = s.replace(/<span class="pwText">[^<]*&\S*;[^<]*<\/span>/g, function (m) { return m.replace(/(&[^;]+;)/g, '</span><span class="pwSpecial">$1</span><span class="pwText">'); });

            // remove empty pwText tags and wrap in a span.pwText if needed
            // s = s.replace(/<span class="pwText">[\n\r]+?<\/span>/g, "");

            return s;
        },

        // adds the next letter 
        type: function (G) {

            // increase dataIndex, which moves to the next element
            if (G.charCount > G.data[G.dataIndex].count) {
                G.dataIndex++;
            }

            // If typing is complete, restore the original state
            if (G.dataIndex == G.dataLength) {
                G.thisElement.data("finished", true);
                G.thisElement.html(G.content);


                // if typing is complete for ALL elements
                if (G.thisElement.data("callback")) {
                    var finished = true;
                    $(G.thisElement.data("get")).each(function () {
                        if (!$(this).data("finished")) { finished = false; }
                    });
                    if (finished) {
                        var callback = G.thisElement.data("callback");
                        if (callback) {
                            callback.call();
                        }
                    }
                }
                return false;
            }

            // show the current element and all previous elements which are still hidden
            var newOrder = G.data[G.dataIndex].element.data("order");
            for (G.order; G.order <= newOrder; G.order++) {
                G.thisElement.find('.order-' + G.order).removeClass('pwHidden');
            }

            // type the next character
            G.data[G.dataIndex].element.html(G.data[G.dataIndex].text.substr(0, G.charCount - ((G.dataIndex > 0) ? G.data[G.dataIndex - 1].count : 0)));
            G.delay = Math.round(G.minInterval + (Math.random() * (G.maxInterval - G.minInterval)));
            G.thisElement.data("int", setTimeout(function () { $.pwTyper.type(G) }, G.delay));

            G.charCount++;

            // Stores the G data in the element to use in pause and stop functions
            G.thisElement.data("G", G);
        },

        // removes the last letter 
        untype: function (G) {

            // increase dataIndex, which moves to the next element
            if (G.dataIndex > 0 && G.charCount <= G.data[G.dataIndex - 1].count) {
                G.dataIndex--;
            }

            // If untyping is complete
            if (G.charCount === 0) {
                G.thisElement.data("finished", true);
                G.thisElement.html("");

                // if untyping is complete for ALL elements
                if (G.thisElement.data("callback") && $(G.thisElement.data("get")).data('finished')) {
                    var finished = true;
                    $(G.thisElement.data("get")).each(function () {
                        if (!$(this).data("finished")) { finished = false; }
                    });
                    if (finished) {
                        var callback = G.thisElement.data("callback");
                        if (callback) {
                            callback.call();
                        }
                    }
                }
                return false;
            }

            // show the current element and all previous elements which are still hidden
            var newOrder = G.data[G.dataIndex].element.data("order");
            for (G.order; G.order > newOrder; G.order--) {
                G.thisElement.find('.order-' + G.order).remove();
            }

            // type the next character
            G.data[G.dataIndex].element.html(G.data[G.dataIndex].text.substr(0, G.charCount - 1 - ((G.dataIndex > 0) ? G.data[G.dataIndex - 1].count : 0)));
            G.delay = Math.round(G.minInterval + (Math.random() * (G.maxInterval - G.minInterval)));
            G.thisElement.data("int", setTimeout(function () { $.pwTyper.untype(G) }, G.delay));

            G.charCount--;

            // Stores the G data in the element to use in pause and stop functions
            G.thisElement.data("G", G);
        },

        createCSS: function (selector, declaration) {

            // test for IE
            var ua = navigator.userAgent.toLowerCase();
            var isIE = (/msie/.test(ua)) && !(/opera/.test(ua)) && (/win/.test(ua));

            // create the style node for all browsers, if it doesn't already exists	
            var style_node = document.getElementById('pwTyperStyles');
            if (!style_node) {
                style_node = document.createElement("style");
                style_node.setAttribute("type", "text/css");
                style_node.setAttribute("media", "screen");
                style_node.setAttribute("id", "pwTyperStyles");
            }

            // if the rule doesn't already exist, add it
            if (style_node.innerHTML.indexOf(selector + " {" + declaration + "}") === -1) {

                // append a rule for good browsers
                if (!isIE) style_node.appendChild(document.createTextNode(selector + " {" + declaration + "}\n"));

                // append the style node
                document.getElementsByTagName("head")[0].appendChild(style_node);

                // use alternative methods for IE
                if (isIE && document.styleSheets && document.styleSheets.length > 0) {
                    var last_style_node = document.styleSheets[document.styleSheets.length - 1];
                    if (typeof (last_style_node.addRule) == "object") last_style_node.addRule(selector, declaration);
                }
            }
        }
    }
    });


    $.fn.extend({

        stopTyper: function () {
            clearInterval(this.data("int"));
            return this;
        },

        resumeTyper: function () {
            this.data('func').call($.pwTyper, this.data("G"));
            return this;
        },

        finishTyper: function () {
            clearInterval(this.data("int"));
            if (this.data('func') == $.pwTyper.type) {
                this.html(this.data("content"));
            } else {
                this.empty();
            }

            var callback = this.data("callback");
            if (callback) {
                callback.call();
            }

            return this;
        },

        type: function (options) {

            // add CSS styles if they haven't already been added
            $.pwTyper.createCSS('.pwHidden', 'display:none;');

            clearInterval(this.data("int"));

            // Default settings
            var settings = {
                minInterval: 30,
                maxInterval: 90
            };

            // Processing settings
            settings = jQuery.extend(settings, options || {});

            this.data("func", $.pwTyper.type);
            this.data("get", this.get());
            this.data("callback", (settings.callback) ? settings.callback : null);


            return this.each(function () {

                var G = {
                    charCount: 0,
                    charTotal: 0,
                    data: [],
                    dataLength: 0,
                    dataIndex: 0,
                    thisElement: $(this),
                    order: 0,
                    delay: 0,
                    newText: "",
                    content: "",
                    minInterval: settings.minInterval,
                    maxInterval: settings.maxInterval
                };

                if (!settings.content) {
                    G.content = G.thisElement.html();
                } else if (settings.content instanceof jQuery) {
                    G.content = $(settings.content).html();
                } else {
                    G.content = settings.content;
                }
                G.thisElement.data("finished", false);
                G.thisElement.data("content", G.content);

                // wraps all text nodes in a pwText span element 
                G.newText = $.pwTyper.wrap(G.content);

                // Creates an order for all elements to progressively show them as the typing happens
                G.thisElement.html(G.newText).find('*').each(function (i) {
                    $(this).addClass("pwHidden").data("order", i).addClass("order-" + i);
                });

                // empties the text from the span elements and stores it in the 'data' variable
                G.thisElement.find('.pwText').each(function (i) {
                    G.data[i] = {
                        order: $(this).data("order"),
                        text: $(this).html(),
                        element: $(this),
                        count: (i > 0) ? $(this).html().length + G.data[i - 1].count : $(this).html().length
                    };
                    $(this).empty();
                });

                G.dataLength = G.data.length;
                G.charTotal = G.data[G.dataLength - 1].count;

                // if a time is specified, calculate the delay
                if (settings.time) {
                    G.delay = Math.floor(settings.time / G.charTotal);
                    if (G.delay === 0) { G.delay = 1; }
                    if (settings.deviation) {
                        if (settings.deviation > 1) { settings.deviation = 1; }
                        G.minInterval = Math.round(G.delay * (1 - settings.deviation));
                        G.maxInterval = G.delay + (G.delay - G.minInterval);
                        if (G.minInterval === 0) { G.minInterval = 1; }
                    } else {
                        G.minInterval = G.delay;
                        G.maxInterval = G.delay;
                    }
                }

                if (settings.delay) {
                    G.thisElement.data("int", setTimeout(function () { $.pwTyper.type(G) }, settings.delay));
                } else {
                    $.pwTyper.type(G);
                }
            });
        },

        untype: function (options) {

            // add CSS styles if they haven't already been added
            $.pwTyper.createCSS('.pwHidden', 'display:none;');

            clearInterval(this.data("int"));

            // Default settings
            var settings = {
                minInterval: 30,
                maxInterval: 90
            };

            // Processing settings
            settings = jQuery.extend(settings, options || {});

            this.data("func", $.pwTyper.untype);
            this.data("get", this.get());
            this.data("callback", (settings.callback) ? settings.callback : null);


            return this.each(function () {

                var G = {
                    charCount: 0,
                    charTotal: 0,
                    data: [],
                    dataLength: 0,
                    dataIndex: 0,
                    thisElement: $(this),
                    order: 0,
                    delay: 0,
                    newText: "",
                    content: $(this).html(),
                    minInterval: settings.minInterval,
                    maxInterval: settings.maxInterval
                };
                G.thisElement.data("finished", false);

                // wraps all text nodes in a pwText span element 
                G.newText = $.pwTyper.wrap(G.content);

                // Creates an order for all elements to progressively show them as the typing happens
                G.thisElement.html(G.newText).find('*').each(function (i) {
                    $(this).data("order", i).addClass("order-" + i);
                });

                // takes the text from the span elements and stores it in the 'data' variable
                G.thisElement.find('.pwText').each(function (i) {
                    G.data[i] = { order: $(this).data("order"), text: $(this).html(), element: $(this), count: (i > 0) ? $(this).html().length + G.data[i - 1].count : $(this).html().length };
                });

                if (G.data.length > 0) {
                    G.dataIndex = G.data.length - 1;
                    G.charTotal = G.data[G.dataIndex].count;
                    G.charCount = G.charTotal;
                    G.order = G.data[G.dataIndex].element.data("order");

                    // if a time is specified, calculate the delay
                    if (settings.time) {
                        G.delay = Math.floor(settings.time / G.charTotal);
                        if (G.delay === 0) { G.delay = 1; }
                        if (settings.deviation) {
                            if (settings.deviation > 1) { settings.deviation = 1; }
                            G.minInterval = Math.round(G.delay * (1 - settings.deviation));
                            G.maxInterval = G.delay + (G.delay - G.minInterval);
                            if (G.minInterval === 0) { G.minInterval = 1; }
                        } else {
                            G.minInterval = G.delay;
                            G.maxInterval = G.delay;
                        }
                    }
                }

                if (settings.delay) {
                    G.thisElement.data("int", setTimeout(function () { $.pwTyper.untype(G) }, settings.delay));
                } else {
                    $.pwTyper.untype(G);
                }
            });

        }
    });

})(jQuery);