var ready = require('asyncready.js');
 

var r = ss.ready('jobDone');

// our ready watch was stored in var r
r.addCheck('db_write_one');
 
// we can get the same ready watch every time we call ss.ready('jobDone')
ss.ready('jobDone')
    .addCheck('db_write_two') // ... and chain our method calls
    .addCheck('db_read_one')
    .addCheck('file_op_one');

// As per our scenario we want to execute x, y and z functions:
var r = ss.ready('jobDone');
r.addListener(x)
    .addListener(y) // chain chain chain
    .addListener(z);

// let's check db write one first...
client.set('one', 'this is db write one', function(err, reply){
    /* Your stuff here */
 
    // declare db write one check is finished
    ss.ready('jobDone').check('db_write_one', 'we can pass', 'any number', 'of arguments');
});
 
/* In the meantime... */
 
// A cool feature with checks is that every added check on our
// ready watch creates a method with the name we used.
// So for cases where we don't want to create an anon func
// we can inline the check call like this:
client.set('two', 'this is db write two', ss.ready('jobDone').db_write_two);
 
/* Let's finish this up now... */
 
// two remaining checks todo, remember to call the checks in any outcome
// of your async operations, success or failure!
client.get('this_key_doesnt_exist', function(err, reply){
    /* handle your error but ALWAYS check your watch! */
    ss.ready('jobDone').check('db_read_on', false);
    // we passed a false argument so we can inform our
    // listeners of the false state
});
 
// the file read operation...
fs.read(fd, buffer, offset, length, position, function(err, bytesRead, buffer){
    /* do your magic */
    ss.ready('jobDone').check('file_op_one');
});

var r = ss.ready('authDone');
r.addCheck('facebookDone');
 
r.addCheck('twitterDone')
    // let's try chaining...
    .addCheck('localDone');
 
/* Do your stuff, add listeners, etc */
 
// facebook finished
r.check('facebookDone');
 
// twitter finished, use the newly created
// method to declare it's done
r.twitterDone();
// do the same with local auth
r.localDone();
 

var r = ss.ready('appReady');
r.addCheck('DOM');
r.addCheck('auth');
r.addCheck('serverDataObjects');
 
// When our app is ready execute allDone to cleanup and update UI
ss.ready('appReady').addListener(allDone)
// load widgets when our app is ready
    .addListener(loadTwitter);
    // load calendar widget after app is ready
    .addListener(loadCalendar);
 

var r = ss.ready('go ready go');
// add a check
r.addCheck('theCheck');
 
// add a check listener
ss.ready('go ready go').addCheckListener(allDone)
 
// gotta love func expressions
function allDone(status, message) {
    status === true; // true
    message === 'foo'; // true too
}
 
/* ... */
 
// check the check
ss.ready('go ready go').theCheck(true, 'foo');

var r = ss.ready('appReady');
r.addCheck('DOM');
r.addCheck('auth');
 
// declare our listener function
// 'ready' is the instance of the ready watch
var onAppReady = function(ready) {
 
    // get auth resolution
    var authArgs = ready.getArgs('auth');
 
    authArgs[0] === true; // true
    authArgs[1] === {nick: 'foo'}; // also true (if only we could deep compare)
};
 
ss.ready('appReady').addListener(onAppReady);
 
/* ... */
// listen for DOM ready event
var r = ss.ready('appReady');
jQuery.ready(r.DOM);
 
// our auth resolution function...
function userResolution(var_args) {
    // stuff
    // more stuff
 
    // oh we have an authed user, run check and
    // declare it
    ss.ready('appReady').check('auth', true, {nick: 'foo'});
}
 

 
function appReady(ready) {
    /* do stuff */
 
    // check if facebook authed us
    if (ready.getArgs('facebookAuth')[0]) {
        // we are authed from FB
    }
}
 
// we'll use the main event to attach the appReady callback
ss.ready(appReady);
 
// load a few libs when app is ready
ss.ready(loadTwitter);
ss.ready(loadCalWidget);
 
// now add the checks that we want to watch
var r = ss.ready(); // ready with no params, returns the default 'main' watch
 
r.addCheck('DOM')
    .addCheck('facebookAuth')
    .addCheck('uiReady');
 
// attach to document ready event using jQuery and inline execute DOM check
$(document).ready(ss.ready().DOM);
 
/* ... */
 
// Listen for Facebook initial login status
FB.getLoginStatus(function(response){
    // check if we are authed with FB
    var isAuthed = 'connected' == response['status'];
    /* do your stuff */
 
    // Check facebook watch
    ss.ready().facebookAuth(isAuthed);
});
 
/* ... */
 
// when our UI is ready and responsive trigger the ui check
ss.ready().check('uiReady');
 
/* ... */
 

var r = ss.ready('allDone');
r.addCheck('doneOne');
r.addCheck('doneTwo');
 
/* ... */
 
r.check('doneOne');
r.check('doneTwo');
 
/* ... */
 
r.addListener(function(ready){
    /* will execute synchronously as the ready watch has finished */
});

 
/**
 * A callback method for an ajax call to our
 * server that has loaded a set of users.
 *
 * We have to render them and emit an event when
 * all ui / ux is done
 *
 * @param {Array.<Object>} allUsers an array with user objects
 * @return {void} 
 */
users.prototype.renderUsers = function(allUsers) {
    // prepare our ready watch, force init as this is a repeative
    // call and we don't want to load previous state
    var r = ss.ready('usersRendered', true);
 
    // add checks for our two main operations
    r.addCheck('allParsed')
    r.addCheck('uiReady');
 
    // when all done execute _usersRenderFinished and apply
    // our current scope
    r.addListener(this._usersRenderFinished, this);
 
    // go through all users
    var user, userBlock;
    for (var i = 0, l = allUsers.length ; i < l ; i++) {
        // get the single user data object
        user = allUsers[i];
        // get the user markup block, from our awesome "class"
        userBlock = new UserBlock(user);
 
        // userBlock needs to load the user's image
        // and appear with a small animation fx on the DOM
        // dynamically create ready checks for these events
        r.addCheck('user-image-loaded' + user.id);
        r.addCheck('user-animation-finished' + user.id);
 
        // now attach the the userBlock's exposed events
        userBlock.listen('imageLoad', r['user-image-loaded' + user.id]);
        userBlock.listen('fxFinished', r['user-animation-finished' + user.id]);
 
        // remember, checks are also assigned as methods on our ready instance.
        //
        // Our unique to this user, checkId ('user-image-loaded' + user.id) let's suppose
        // it evaluates to 'user-image-loaded-444'. So this string literal has also been
        // assigned as a method to the ready instance 'r'.
        //
        // This means we can access it at r['user-image-loaded-444'] and execute
        // it using r['user-image-loaded-444']();
 
        // append our userBlock to the DOM
        $('#users-search-list').append(userBlock.render());
    }
 
    // loop finished, check 'allParased' and pass the user array
    r.check('allParsed', allUsers);
}
 
/**
 * When our UI has finished rendering and UX is done
 * call this function
 * @param {ss.ready} ready The ready instance
 * @return {void} 
 */
users.prototype._usersRenderFinished = function(ready) {
    // re-enable our search button
    $('#button-search-users').removeAttr('disabled');
 
    // get the users array
    var args = ready.getArgs('allParsed');
    var allUsers = args[0];
 
    // now emmit an event that we are done
    ourEventEngine.trigger('users.searchRenderDone', allUsers);
};