/* This piece of code is directly requested by the page the player is embedded

   on. It creates the iframe the player is embedded in and it reflects changes

   to the iframe url in the page url.   

*/

IriSP = {};

window.onhashchange = function() {

  var url = window.location.href;

  var frame = document.getElementById("metadataplayer_embed");

  if ( url.split( "#" )[ 1 ] != null ) {

       hashvalue = url.split("#")[1];

       frame.contentWindow.postMessage({type: "hashchange", value: hashvalue}, "*");

  }    

};

IriSP.handleMessages = function(e) {

  var history = window.history;

  if ( !history.pushState ) {

    return false;

  }

  if (e.data.type === "hashchange") {

    console.log(e.data.value);

    history.replaceState( {}, "", e.data.value);

  }

};

// http://stackoverflow.com/questions/799981/document-ready-equivalent-without-jquery

var ready = (function(){    

    var readyList,

        DOMContentLoaded,

        class2type = {};

        class2type["[object Boolean]"] = "boolean";

        class2type["[object Number]"] = "number";

        class2type["[object String]"] = "string";

        class2type["[object Function]"] = "function";

        class2type["[object Array]"] = "array";

        class2type["[object Date]"] = "date";

        class2type["[object RegExp]"] = "regexp";

        class2type["[object Object]"] = "object";

    var ReadyObj = {

        // Is the DOM ready to be used? Set to true once it occurs.

        isReady: false,

        // A counter to track how many items to wait for before

        // the ready event fires. See #6781

        readyWait: 1,

        // Hold (or release) the ready event

        holdReady: function( hold ) {

            if ( hold ) {

                ReadyObj.readyWait++;

            } else {

                ReadyObj.ready( true );

            }

        },

        // Handle when the DOM is ready

        ready: function( wait ) {

            // Either a released hold or an DOMready/load event and not yet ready

            if ( (wait === true && !--ReadyObj.readyWait) || (wait !== true && !ReadyObj.isReady) ) {

                // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).

                if ( !document.body ) {

                    return setTimeout( ReadyObj.ready, 1 );

                }

                // Remember that the DOM is ready

                ReadyObj.isReady = true;

                // If a normal DOM Ready event fired, decrement, and wait if need be

                if ( wait !== true && --ReadyObj.readyWait > 0 ) {

                    return;

                }

                // If there are functions bound, to execute

                readyList.resolveWith( document, [ ReadyObj ] );

                // Trigger any bound ready events

                //if ( ReadyObj.fn.trigger ) {

                //  ReadyObj( document ).trigger( "ready" ).unbind( "ready" );

                //}

            }

        },

        bindReady: function() {

            if ( readyList ) {

                return;

            }

            readyList = ReadyObj._Deferred();

            // Catch cases where $(document).ready() is called after the

            // browser event has already occurred.

            if ( document.readyState === "complete" ) {

                // Handle it asynchronously to allow scripts the opportunity to delay ready

                return setTimeout( ReadyObj.ready, 1 );

            }

            // Mozilla, Opera and webkit nightlies currently support this event

            if ( document.addEventListener ) {

                // Use the handy event callback

                document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );

                // A fallback to window.onload, that will always work

                window.addEventListener( "load", ReadyObj.ready, false );

            // If IE event model is used

            } else if ( document.attachEvent ) {

                // ensure firing before onload,

                // maybe late but safe also for iframes

                document.attachEvent( "onreadystatechange", DOMContentLoaded );

                // A fallback to window.onload, that will always work

                window.attachEvent( "onload", ReadyObj.ready );

                // If IE and not a frame

                // continually check to see if the document is ready

                var toplevel = false;

                try {

                    toplevel = window.frameElement == null;

                } catch(e) {}

                if ( document.documentElement.doScroll && toplevel ) {

                    doScrollCheck();

                }

            }

        },

        _Deferred: function() {

            var // callbacks list

                callbacks = [],

                // stored [ context , args ]

                fired,

                // to avoid firing when already doing so

                firing,

                // flag to know if the deferred has been cancelled

                cancelled,

                // the deferred itself

                deferred  = {

                    // done( f1, f2, ...)

                    done: function() {

                        if ( !cancelled ) {

                            var args = arguments,

                                i,

                                length,

                                elem,

                                type,

                                _fired;

                            if ( fired ) {

                                _fired = fired;

                                fired = 0;

                            }

                            for ( i = 0, length = args.length; i < length; i++ ) {

                                elem = args[ i ];

                                type = ReadyObj.type( elem );

                                if ( type === "array" ) {

                                    deferred.done.apply( deferred, elem );

                                } else if ( type === "function" ) {

                                    callbacks.push( elem );

                                }

                            }

                            if ( _fired ) {

                                deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );

                            }

                        }

                        return this;

                    },

                    // resolve with given context and args

                    resolveWith: function( context, args ) {

                        if ( !cancelled && !fired && !firing ) {

                            // make sure args are available (#8421)

                            args = args || [];

                            firing = 1;

                            try {

                                while( callbacks[ 0 ] ) {

                                    callbacks.shift().apply( context, args );//shifts a callback, and applies it to document

                                }

                            }

                            finally {

                                fired = [ context, args ];

                                firing = 0;

                            }

                        }

                        return this;

                    },

                    // resolve with this as context and given arguments

                    resolve: function() {

                        deferred.resolveWith( this, arguments );

                        return this;

                    },

                    // Has this deferred been resolved?

                    isResolved: function() {

                        return !!( firing || fired );

                    },

                    // Cancel

                    cancel: function() {

                        cancelled = 1;

                        callbacks = [];

                        return this;

                    }

                };

            return deferred;

        },

        type: function( obj ) {

            return obj == null ?

                String( obj ) :

                class2type[ Object.prototype.toString.call(obj) ] || "object";

        }

    }

    // The DOM ready check for Internet Explorer

    function doScrollCheck() {

        if ( ReadyObj.isReady ) {

            return;

        }

        try {

            // If IE is used, use the trick by Diego Perini

            // http://javascript.nwbox.com/IEContentLoaded/

            document.documentElement.doScroll("left");

        } catch(e) {

            setTimeout( doScrollCheck, 1 );

            return;

        }

        // and execute any waiting functions

        ReadyObj.ready();

    }

    // Cleanup functions for the document ready method

    if ( document.addEventListener ) {

        DOMContentLoaded = function() {

            document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );

            ReadyObj.ready();

        };

    } else if ( document.attachEvent ) {

        DOMContentLoaded = function() {

            // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).

            if ( document.readyState === "complete" ) {

                document.detachEvent( "onreadystatechange", DOMContentLoaded );

                ReadyObj.ready();

            }

        };

    }

    function ready( fn ) {

        // Attach the listeners

        ReadyObj.bindReady();

        var type = ReadyObj.type( fn );

        // Add the callback

        readyList.done( fn );//readyList is result of _Deferred()

    }

    return ready;

})();

ready(function() { window.addEventListener('message', IriSP.handleMessages, false); });