/**
 *  @author : Adam Portilla
 *  
 *  @permissions : This is work in progress code, so please
 *                 do not use without permission.
 *
 *  @author-website :  http://blackasteroid.net
 */
 
/**
 *  Verify AP namespace
 *  
 */
if (typeof AP != 'object'){

    var AP = {};

}

/**
 *  Use YUI3 Autoloader
 */
YUI().use('anim','node', function(Y) {

    /**
     *  Return a reusable overlay object
     */
    AP.overlayView = function(p,my){
        
        var that = {};  // public
        my = my || {};  // private
        p = p || {};    // config
        
        /* configuration settings */
        my.active = false;
        my.loaded = false;
        my.image = {};
        my.metadataHeight = 0;
        my.postNode = 0;
        my.bgOpacity = .90;
        my.fadeTime = .4;
        my.playlist = [];
        
		/* Create a node reference to the doc body */
        my.documentNode = Y.get(document.body);
        
        /* Create Overlay Container Node */
        my.overlayNode = Y.get(document.createElement('div'));
        my.overlayNode.addClass('overlayContainer');
        
        /* Create Background Skrim Node */
        my.backgroundNode = Y.get(document.createElement('div'));
        my.backgroundNode.addClass('overlayBackground');
        
        /* Create Media Container Node */
        my.mediaContainerNode = Y.get(document.createElement('div'));
        my.mediaContainerNode.addClass('overlayMedia');

        /* Create Meta-Title Node */
        my.metaTitleNode = Y.get(document.createElement('div'));
        my.metaTitleNode.addClass('overlayTitle');

        /* Create Meta-Caption Node */
        my.metaCaptionNode = Y.get(document.createElement('div'));
        my.metaCaptionNode.addClass('overlayCaption');

        /* Create Loader Gif Node */
        my.loaderNode = Y.get(document.createElement('img'));
        my.loaderNode.addClass('mediaLoader');
        my.loaderNode.setAttribute('src','medialoader.gif');
        my.loaderNode.setAttribute('height',16);
        my.loaderNode.setAttribute('width',16);
        
        /* Create Button Nodes */
        my.closeBtnNode = Y.get(document.createElement('div'));
        my.closeBtnNode.addClass('overlayCloseBtn');
        my.closeBtnNode.setStyle('opacity',0);
        
        my.nextBtnNode = Y.get(document.createElement('div'));
        my.nextBtnNode.addClass('overlayNextBtn');
        my.nextBtnNode.setStyles('opacity',0);
        
        my.prevBtnNode = Y.get(document.createElement('div'));
        my.prevBtnNode.addClass('overlayPrevBtn');
        my.prevBtnNode.setStyle('opacity',0);

       	/* Place nodes into the overlay */ 
        my.mediaContainerNode.append(my.closeBtnNode);
        my.overlayNode.append(my.backgroundNode);
        my.overlayNode.append(my.mediaContainerNode);
        my.overlayNode.append(my.prevBtnNode);
        my.overlayNode.append(my.nextBtnNode);
		
		/*
		 *  Get Scaled Image Dimensions
		 *  Takes an object literal with a height and width
		 *  property and returns an object literal with
		 *  a height and width property scaled down to fit
		 *  within a containerNodes width
		 */
        my.scaleDimensions = function(height,width,containerNode) {
            var imageHeight = height;
            var imageWidth = width;
            var imageRatio = imageWidth/imageHeight;
            var availWidth = containerNode.get('offsetWidth') - 40;
            var scaledSize = {};

            scaledSize.height = Math.floor(availWidth / imageRatio);
            scaledSize.width = availWidth;

            return scaledSize;
        };
 
        /* background animation */
        my.backgroundAnim = new Y.Anim({
            node:my.backgroundNode,
            duration:my.fadeTime,
            easing:Y.Easing.easeBoth,
            to:{opacity : my.bgOpacity}
        });
 
        /* media container animation */
        my.mediaContainerAnim = new Y.Anim({
            node:my.mediaContainerNode,
            duration:my.fadeTime,
            easing:Y.Easing.easeBoth,
            to:{opacity : 1}
        });

		/* decide which buttons should be displayed */
        my.resetNavBtns = function(){
            if (my.currentIndex > 0){
                my.showPrevBtn();
            } else {
                my.hidePrevBtn();
            }
            if (my.currentIndex < (my.playlist.length - 1)){
                my.showNextBtn();
            } else {
                my.hideNextBtn();
            }
        };
        
  		/* first link of the overlay activation animation chain
  		 * append the overlaynode to document and animate
  		 * the background layers opacity
  		 */
        my.turnOverlayOn = function(){
            my.documentNode.append(my.overlayNode);
            my.backgroundNode.setStyle('zIndex',100);
            my.backgroundAnim.stop();
            my.backgroundAnim.set('to',{opacity:my.bgOpacity});
            my.backgroundAnim.on('end',my.activateMediaContainer);
            my.backgroundAnim.run();
        };
        
  		/* second link of the overlay activation animation chain
  		 * Get the media object, scale the media container to
  		 * the correct size, and show the nav buttons
  		 */
        my.activateMediaContainer = function(){
            my.backgroundAnim.detachAll();
            my.mediaContainerNode.setStyles({
                opacity: 1,
                zIndex: 200
            });
            my.resetCurrentMedia();
            my.onMediaContainerReady();
            my.showCloseBtn();
            my.resetNavBtns();

        };
		
		/* once the media container has finished scaling to the media size
		 * append the media node into the container and
		 * display it
		 */
        my.onMediaContainerReady = function(){
            my.mediaContainerAnim.detachAll();
            my.mediaContainerNode.prepend(my.postNode);
            my.loaded = true;
        };
        
        /* fist step in the deactivation sequence, hide all the buttons
         * and fade out the media
         */
        my.turnOverlayOff = function(){
            my.loaded = false;
            my.hideCloseBtn();
            my.hidePrevBtn();
            my.hideNextBtn();
            my.mediaContainerAnim.stop();
            my.mediaContainerAnim.set('to',{opacity:0});
            my.mediaContainerAnim.on('end',my.deactivateBackground);
            my.mediaContainerAnim.run();
        };
        
        /* second step in the deactivation sequence, remove image node
         * from the media container, and fade out the background skrim
         */
        my.deactivateBackground = function(){
            my.mediaContainerAnim.detachAll();
            my.mediaContainerNode.removeChild(my.postNode);
            my.backgroundAnim.stop();
            my.backgroundAnim.set('to',{opacity:0});
            my.backgroundAnim.on('end',my.deactivateOverlay);
            my.backgroundAnim.run();
        }
		
		/* final step in the deactivation sequence, remove the overlay
		 * node from the document
		 */
        my.deactivateOverlay = function(){
            my.backgroundAnim.detachAll();
            my.documentNode.removeChild(my.overlayNode);
            my.active = false;
            my.loaded = false;
        };
        
        /*  reset the overlays internal pointers to the current media
         *  , it's display dimensions, and it's node
         */
        my.resetCurrentMedia = function(){
            my.postNode = my.playlist[my.currentIndex];
            /*
            my.image = AP.imageElement(my.playlist[my.currentIndex]);
            my.imageSize = my.scaleDimensions(
            	my.image.getHeight(),
            	my.image.getWidth(),
            	my.mediaContainerNode
    		);
            my.imageNode = my.image.getNode();
            */
        };
        
        
        /*
         *  switch the active media item to the one with
         *  the specified index
         */
        my.switchMedia = function(newIndex){
        	/* only switch if the current item is loaded
        	 * ( this prevents click hammering the script )
        	 */
            if (my.loaded){
                my.loaded = false;
                my.currentIndex = newIndex;
                my.resetNavBtns();
                
                my.mediaContainerNode.removeChild(my.postNode);
                my.resetCurrentMedia();
                my.onMediaContainerReady();
            }
        };
        
        /* show/hide the prev/next/close buttons */
        my.showPrevBtn = function(){my.prevBtnNode.setStyle('opacity',1);};
        my.hidePrevBtn = function(){my.prevBtnNode.setStyle('opacity',0);};
        my.showNextBtn = function(){my.nextBtnNode.setStyle('opacity',1);};
        my.hideNextBtn = function(){my.nextBtnNode.setStyle('opacity',0);};
        my.showCloseBtn = function(){my.closeBtnNode.setStyle('opacity',1);};
        my.hideCloseBtn = function(){my.closeBtnNode.setStyle('opacity',0);};
        

        /* click event for background panel */	
        my.backgroundNode.on('click',function(){
            if (my.loaded){
                my.turnOverlayOff();
            }
        },this);
        
        /* click event for close button */	
        my.closeBtnNode.on('click',function(){
            if (my.loaded){
                my.turnOverlayOff();
            }
        },this);
        
        /* click event for next button */	
        my.nextBtnNode.on('click',function(){
            if (my.currentIndex < (my.playlist.length - 1)){
                my.switchMedia(my.currentIndex + 1);
            }
        },this);

        /* click event for prev button */	
        my.prevBtnNode.on('click',function(){
            if (my.currentIndex >= 1){
                my.switchMedia(my.currentIndex - 1);
            }
        },this);

        /* display overlay with item passed in via media */
        that.show = function(index){
        
            /* default to the first item if no index is specified */
            index = index || 0;
               
            /* ignore show events when the current overlay is active */
            if (!my.active){
                my.active = true;
                my.currentIndex = index;
                my.turnOverlayOn();
            }
        };
        
        /*
         *  set the playlist used by the overlay, this is required
         *  since the 'show' function takes only an index
         */
        that.setPlaylist = function(list){
            my.playlist = list;
        };
        
        return that;
        
    };


    /*
     *  Communicate with the tumblr api
     */
    AP.tumblr = function(TB) {
        
        /**
         *  Define the private internal namespace of this object
         */
        TB = TB || {};
        
        TB.responses = [];

        TB.getTumblrBlog = function(p,my){
            
            var that = {};
            my = my || {};
            p = p || {};
            
            my.responseCache = {};
            
            /**
             *  Use the provided callback.
             */
            my.callback = p.callback || function(){};

            /**
             *  Use the provided tumblr blog url.
             */
            my.blogUrl = p.blogUrl || 'blackasteroid.tumblr.com';

            my.start = p.start || 0;
            
            my.num = p.num || 10;
            
            my.tagged = p.tagged || "";
            
            /**
             *  Generate the API URL,  uses the set api_key and photoset_id
             */
            my.getTumblrApiUrl = function(){
                return "http://"
                       + my.blogUrl
                       + "/api/read/json/"
                       + "?callback=AP.tumblr._jsonCallback"
                       + "&start=" + my.start
                       + "&num=" + my.num
                       + "&tagged=" + encodeURI(my.tagged);
            };
            
            /**
             *  Fire the YUI GET request, and call the callback function when it is 
             *  complete, popping the new result off the responses array.
             */
            my.fireGetRequest = function(){
                
                my.reqUrl = my.getTumblrApiUrl();
                
                if (typeof my.responseCache[my.reqUrl] == "object"){
                    my.callback(my.responseCache[my.reqUrl]);
                } else {
                    my.objTransaction = Y.Get.script(my.reqUrl,
                    { onSuccess: function() {
                        var result = TB.responses.pop();
                        my.responseCache[my.reqUrl] = result;
                        if(typeof result == "object"){
                            my.callback(result);
                        }
                    }});
                }
                    
                
            };
            
            /*
             *  Fire the get request for the next page of posts
             */
            that.nextPage = function(params){
                params = params || {};
                my.start = parseInt(my.start) + parseInt(my.num);
                my.callback = params.callback || my.callback;
                my.fireGetRequest();
            };
            
            /*
             *  Fire the get request for the previous page of posts
             */
            that.previousPage = function(params){
                params = params || {};
                my.start = (parseInt(my.start) <= parseInt(my.num))? 0 : parseInt(my.start) - parseInt(my.num);
                my.callback = params.callback || my.callback;
                my.fireGetRequest();
            };   
            
            /*
             *  Fire the get request on object instantiation
             */
            my.fireGetRequest();
            
            
            /*
             *  Returns
             *  {
             *      nextPage: function(),
             *      previousPage: function()
             *  }
             */
            return that;
        };
        
        
        return {

            /**
             *  _jsonCallback 
             *  
             *  all Get requests trigger this
             *  function, pushing the response into the responses array.
             *                 
             *  The success function for the get request pops the new response off
             *  the responses array and fires the user-provided callback function
             *  with the response data.
             */
            _jsonCallback : function(p){
                TB.responses.push(p);
            },

            getBlog : function(p){
                return TB.getTumblrBlog(p);
            }
            
        };
        
    }();
    

    AP.initTumblr = function(p,my){
        
        my = my || {};
        p = p || {};
        
        my.wrapperNode = Y.get("#tumblrBlog");
        my.postsNode = Y.get("#tumblrPosts");
        my.prevBtnNodes = Y.all(".tumblrPrevPage");
        my.nextBtnNodes = Y.all(".tumblrNextPage");
        my.url = my.wrapperNode.getAttribute('url') || 'blackasteroid.tumblr.com';
        my.num = my.wrapperNode.getAttribute('num') || 10;
        my.tagged = my.wrapperNode.getAttribute('tagged') || '';
        my.total = null;
        my.start = null;
        my.posts = [];
        
        /*
         *  Define functions to return a post node for each post type
         */
        
        my.getRegularNode = function(postdata){
            var postNode = Y.get(document.createElement('div'));
            var postTitle = Y.get(document.createElement('h3'));
            var postBody = Y.get(document.createElement('div'));
            postTitle.setContent(postdata['regular-title'] || "&nbsp;").addClass('title');
            postBody.setContent(postdata['regular-body'] || "&nbsp;").addClass('body');
            postNode.append(postTitle);
            postNode.append(postBody);
            postNode.addClass('tumblrPost').addClass('regularPost');
            return postNode;
        };
        
        my.getRegularPodNode = function(postdata){
            var postNode = Y.get(document.createElement('div'));
            var postTitle = Y.get(document.createElement('div'));
            postTitle.setContent(postdata['regular-title'] || "&nbsp;").addClass('caption');
            postNode.append(postTitle);
            postNode.addClass('tumblrPostPod').addClass('regularPostPod');
            return postNode;
        };
        
        my.getPhotoNode = function(postdata, index){   
        
            var postNode = Y.get(document.createElement('div'));
            var photoImage = new Image;
            var photoCaption = Y.get(document.createElement('div'));

            if (typeof index == "number"){
                photoImage.src = postdata.photos[index]['photo-url-500'];
                var photoTitle = Y.get(document.createElement('h3'));
                photoTitle.setContent(postdata.photos[index]['caption'] || "&nbsp;").addClass('phototitle');
                postNode.append(photoTitle);
            } else {
                photoImage.src = postdata['photo-url-500'];
            }
            
            postNode.append(photoImage);
            photoCaption.setContent(postdata['photo-caption'] || "&nbsp;").addClass('caption');
            postNode.append(photoCaption);
            postNode.addClass('tumblrPost').addClass('photoPost');
            return postNode;
        };

        my.getPhotoPodNode = function(postdata){   
            var postNode = Y.get(document.createElement('div'));
            var photoDiv = Y.get(document.createElement('div'));
            photoDiv.setStyles({
                'backgroundImage':"url('"+postdata['photo-url-250']+"')",
                'backgroundRepeat':"no-repeat",
                'backgroundPosition':'left center',
                'width':'250px',
                'height':'138px'
            });
            var photoCaption = Y.get(document.createElement('div'));
            photoCaption.setContent(postdata['photo-caption'] || "&nbsp;").addClass('caption');
            postNode.append(photoDiv);
            postNode.append(photoCaption);
            postNode.addClass('tumblrPostPod').addClass('photoPostPod');
            return postNode;
        };

        my.getQuoteNode = function(postdata){   
            var postNode = Y.get(document.createElement('div'));
            var quoteText = Y.get(document.createElement('h3'));
            var quoteSource = Y.get(document.createElement('h4'));
            quoteText.setContent('"'+postdata['quote-text']+'"').addClass('body');
            quoteSource.setContent("- "+postdata['quote-source']).addClass('caption');
            postNode.append(quoteText);
            postNode.append(quoteSource);
            postNode.addClass('tumblrPost').addClass('quotePost');
            return postNode;
        };
        
        my.getQuotePodNode = function(postdata){   
            var postNode = Y.get(document.createElement('div'));
            var quoteText = Y.get(document.createElement('div'));
            quoteText.setContent('"'+postdata['quote-text']+'"').addClass('caption');
            postNode.append(quoteText);
            postNode.addClass('tumblrPostPod').addClass('quotePostPod');
            return postNode;
        };

        my.getLinkNode = function(postdata){   
            var postNode = Y.get(document.createElement('div'));
            var headerNode = Y.get(document.createElement('h3'));
            var linkTag = Y.get(document.createElement('a'));
            var linkDescription = Y.get(document.createElement('div'));
            linkTag.setContent(postdata['link-text'] || "LINK").addClass('title');
            linkTag.set('href',postdata['link-url']);
            linkDescription.setContent(postdata['link-description'] || "&nbsp;").addClass('body');
            headerNode.append(linkTag);
            postNode.append(headerNode);
            postNode.append(linkDescription);
            postNode.addClass('tumblrPost').addClass('linkPost');
            return postNode;
        };
        
        my.getLinkPodNode = function(postdata){   
            var postNode = Y.get(document.createElement('div'));
            var linkTag = Y.get(document.createElement('div'));
            linkTag.setContent(postdata['link-text'] || "LINK").addClass('caption');
            postNode.append(linkTag);
            postNode.addClass('tumblrPostPod').addClass('linkPostPod');
            return postNode;
        };

        my.getVideoNode = function(postdata){ 
            var postNode = Y.get(document.createElement('div'));
            var videoPlayer = Y.get(document.createElement('div'));
            var videoCaption = Y.get(document.createElement('div'));
            videoPlayer.setContent(postdata['video-source'] || "&nbsp;").addClass('body');
            videoCaption.setContent(postdata['video-caption'] || "&nbsp;").addClass('caption');
            postNode.append(videoPlayer);
            postNode.append(videoCaption);
            postNode.addClass('tumblrPost').addClass('videoPost');
            return postNode;
        };
        
        my.getVideoPodNode = function(postdata){ 
            var postNode = Y.get(document.createElement('div'));
            var videoCaption = Y.get(document.createElement('div'));
            videoCaption.setContent(postdata['video-caption'] || "&nbsp;").addClass('caption');
            postNode.append(videoCaption);
            postNode.addClass('tumblrPostPod').addClass('videoPostPod');
            return postNode;
        };

        my.getConversationNode = function(postdata){   
            var postNode = Y.get(document.createElement('div'));
            for (var i=0;i<=postdata.conversation.length - 1;i++){
                var conv = Y.get(document.createElement('div'));
                var label = Y.get(document.createElement('div'));
                var phrase = Y.get(document.createElement('div'));
                label.setContent(postdata.conversation[i]['label'] || "&nbsp;").addClass('label');
                phrase.setContent(postdata.conversation[i]['phrase'] || "&nbsp;").addClass('phrase');
                conv.append(label).append(phrase).addClass('item');
                postNode.append(conv);
            }
            postNode.addClass('tumblrPost').addClass('conversationPost');
            return postNode;
        };

        my.getConversationPodNode = function(postdata){   
            var postNode = Y.get(document.createElement('div'));
            var captionNode = Y.get(document.createElement('div'));
            for (var i=0;i<=postdata.conversation.length - 1;i++){
                if (i <= 1){                    
                    var conv = Y.get(document.createElement('div'));
                    var label = Y.get(document.createElement('div'));
                    var phrase = Y.get(document.createElement('div'));
                    label.setContent(postdata.conversation[i]['label'] || "&nbsp;").addClass('label');
                    phrase.setContent(postdata.conversation[i]['phrase'] || "&nbsp;").addClass('phrase');
                    conv.append(label).append(phrase).addClass('item');
                    captionNode.append(conv);
                }
            }
            captionNode.addClass('caption');
            postNode.append(captionNode);
            postNode.addClass('tumblrPostPod').addClass('conversationPostPod');
            return postNode;
        };

        my.getAudioNode = function(postdata){
            var postNode = Y.get(document.createElement('div'));
            var audioPlayer = Y.get(document.createElement('div'));
            var audioCaption = Y.get(document.createElement('div'));
            audioPlayer.setContent(postdata['audio-player'] || "&nbsp;").addClass('body');
            audioCaption.setContent(postdata['audio-caption'] || "&nbsp;").addClass('caption');
            postNode.append(audioPlayer);
            postNode.append(audioCaption);
            postNode.addClass('tumblrPost').addClass('audioPost');;
            return postNode;
        };

        my.getAudioPodNode = function(postdata){
            var postNode = Y.get(document.createElement('div'));
            var audioCaption = Y.get(document.createElement('div'));
            audioCaption.setContent(postdata['audio-caption'] || "&nbsp;").addClass('caption');
            postNode.append(audioCaption);
            postNode.addClass('tumblrPostPod').addClass('audioPostPod');
            return postNode;
        };

        my.getOtherNode = function(postdata){
            var postNode = Y.get(document.createElement('div'));
            var postTitle = Y.get(document.createElement('h3'));
            postTitle.setContent(postdata.type);
            postNode.append(postTitle);
            postNode.addClass('tumblrPost');
            return postNode;
        };
        
        
        /*
         *  Loop through the posts from a tumblr api response, retrieving the 
         *  the formatted postNodes and building the overlay whenever a postNode
         *  is clicked.
         */
        my.renderPostsIntoContainer = function(postdata){

            my.overlay = AP.overlayView();
                
            my.postsNode.setContent("<span></span>");
            my.total = postdata['posts-total'];
            my.start = postdata['posts-start'];
            my.posts = postdata.posts;

            var triggerOverlay = function(clickevent,clickedpost){
               
               var overlayNodes = []; 
                 
               switch(clickedpost.type)
                {
                case "quote":
                  overlayNodes.push(new my.getQuoteNode(clickedpost));
                  break;
                case "regular":
                  overlayNodes.push(new my.getRegularNode(clickedpost));
                  break;
                case "photo":
                  if (clickedpost.photos.length >= 1){
                    for (var j=0;j<=clickedpost.photos.length - 1;j++)
                    {
                        overlayNodes.push(new my.getPhotoNode(clickedpost,j));  
                    }
                  } else {
                    overlayNodes.push(new my.getPhotoNode(clickedpost));
                  }
                  break;
                case "link":
                  overlayNodes.push(new my.getLinkNode(clickedpost));
                  break;
                case "conversation":
                  overlayNodes.push(new my.getConversationNode(clickedpost));
                  break;
                case "video":
                  overlayNodes.push(new my.getVideoNode(clickedpost));
                  break;
                case "audio":
                  overlayNodes.push(new my.getAudioNode(clickedpost));
                  break;
                default:
                }

                my.overlay.setPlaylist(overlayNodes);
                my.overlay.show(0);
            };
            
            
            for (var i=0;i<=my.posts.length - 1;i++)
            {
                switch(my.posts[i].type)
                {
                case "quote":
                  var postPodNode = new my.getQuotePodNode(my.posts[i]);
                  break;
                case "regular":
                  var postPodNode = new my.getRegularPodNode(my.posts[i]);
                  break;
                case "photo":
                  var postPodNode = new my.getPhotoPodNode(my.posts[i]);
                  break;
                case "link":
                  var postPodNode = new my.getLinkPodNode(my.posts[i]);
                  break;
                case "conversation":
                  var postPodNode = new my.getConversationPodNode(my.posts[i]);
                  break;
                case "video":
                  var postPodNode = new my.getVideoPodNode(my.posts[i]);
                  break;
                case "audio":
                  var postPodNode = new my.getAudioPodNode(my.posts[i]);
                  break;
                default:
                  var postPodNode = Y.get(document.createElement('div'));
                  postPodNode.setContent("unknown post type");
                }
                            
                postPodNode.on('click',triggerOverlay,true,my.posts[i]);

                my.postsNode.append(postPodNode);
            }
            
            my.setButtonVisibility();

        };
        
        /*
         *  Create the blog object from the AP.tumblr namespace
         */
        my.blog = AP.tumblr.getBlog({
            blogUrl :my.url,
            num     :my.num,
            tagged  :my.tagged,
            callback:my.renderPostsIntoContainer
        });

        /*
         *  Listen to click events on the previous buttons
         */
        my.prevBtnNodes.on('click',function(){
            if (parseInt(my.start) > 0){
                my.blog.previousPage();
            }
        },this);

        /*
         *  Listen to click events on the next buttons
         */
        my.nextBtnNodes.on('click',function(){
            if (parseInt(my.total) > parseInt(my.start) + parseInt(my.num)){
                my.blog.nextPage();
            };
        },this);
        
        my.setButtonVisibility = function(){

            if (parseInt(my.start) <= 0){
                my.prevBtnNodes.each(function(node){
                    node.setStyles({
                        'opacity':.4,
                        'cursor':'default'
                    });
                });
            } else {
                my.prevBtnNodes.each(function(node){
                    node.setStyles({
                        'opacity':1,
                        'cursor':'pointer'
                    });
                });
            }
            
            if ((parseInt(my.total) <= parseInt(my.start) + parseInt(my.num)) || 
                (my.num > my.posts.length)){
                my.nextBtnNodes.each(function(node){
                    node.setStyles({
                        'opacity':.4,
                        'cursor':'default'
                    });
                });
            } else {
                my.nextBtnNodes.each(function(node){
                    node.setStyles({
                        'opacity':1,
                        'cursor':'pointer'
                    });
                });
            }

        };

    };
    
    /*
     *  Initialize the tumblr api script after yui node has been loaded
     */
    //AP.initTumblr();

    if (AP.tumblrReady == true){
        AP.initTumblr();
    } else {
        AP.tumblrReady = true;
    }
    

});