var _ = require( 'underscore' );
/*
 machina.js
 Author: Jim Cowart
 License: Dual licensed MIT (http://www.opensource.org/licenses/mit-license) & GPL (http://www.opensource.org/licenses/gpl-license)
 Version 0.1.0
 */

var slice = [].slice,
	NEXT_TRANSITION = "transition",
	NEXT_HANDLER = "handler",
	transformEventListToObject = function ( eventList ) {
		var obj = {};
		_.each( eventList, function ( evntName ) {
			obj[evntName] = [];
		} );
		return obj;
	},
	parseEventListeners = function ( evnts ) {
		var obj = evnts;
		if ( _.isArray( evnts ) ) {
			obj = transformEventListToObject( evnts );
		}
		return obj;
	},
	utils = {
		makeFsmNamespace : (function () {
			var machinaCount = 0;
			return function () {
				return "fsm." + machinaCount++;
			};
		})(),
		getDefaultOptions : function () {
			return {
				initialState : "uninitialized",
				eventListeners : {
					"*" : []
				},
				states : {},
				eventQueue : [],
				namespace : utils.makeFsmNamespace()
			};
		}
	},
	Fsm = function ( options ) {
		var opt, initialState, defaults = utils.getDefaultOptions();
		if ( options ) {
			if ( options.eventListeners ) {
				options.eventListeners = parseEventListeners( options.eventListeners );
			}
			if ( options.messaging ) {
				options.messaging = _.extend( {}, defaults.messaging, options.messaging );
			}
		}
		opt = _.extend( defaults, options || {} );
		initialState = opt.initialState;
		delete opt.initialState;
		_.extend( this, opt );

		this.state = undefined;
		this._priorAction = "";
		this._currentAction = "";
		if ( initialState ) {
			this.transition( initialState );
		}
		machina.fireEvent( "newFsm", this );
	};

Fsm.prototype.fireEvent = function ( eventName ) {
	var args = arguments;
	_.each( this.eventListeners["*"], function ( callback ) {
		try {
			callback.apply( this, slice.call( args, 0 ) );
		} catch ( exception ) {
			if ( console && typeof console.log !== "undefined" ) {
				console.log( exception.toString() );
			}
		}
	} );
	if ( this.eventListeners[eventName] ) {
		_.each( this.eventListeners[eventName], function ( callback ) {
			try {
				callback.apply( this, slice.call( args, 1 ) );
			} catch ( exception ) {
				if ( console && typeof console.log !== "undefined" ) {
					console.log( exception.toString() );
				}
			}
		} );
	}
};

Fsm.prototype.handle = function ( msgType ) {
	// vars to avoid a "this." fest
	var states = this.states, current = this.state, args = slice.call( arguments, 0 ), handlerName;
	this.currentActionArgs = args;
	if ( states[current] && (states[current][msgType] || states[current]["*"]) ) {
		handlerName = states[current][msgType] ? msgType : "*";
		this._currentAction = current + "." + handlerName;
		this.fireEvent.apply( this, ["Handling"].concat( args ) );
		states[current][handlerName].apply( this, args.slice( 1 ) );
		this.fireEvent.apply( this, ["Handled"].concat( args ) );
		this._priorAction = this._currentAction;
		this._currentAction = "";
		this.processQueue( NEXT_HANDLER );
	}
	else {
		this.fireEvent.apply( this, ["NoHandler"].concat( args ) );
	}
	this.currentActionArgs = undefined;
};

Fsm.prototype.transition = function ( newState ) {
	if ( this.states[newState] ) {
		var oldState = this.state;
		this.state = newState;
		if ( this.states[newState]._onEnter ) {
			this.states[newState]._onEnter.call( this );
		}
		this.fireEvent.apply( this, ["Transitioned", oldState, this.state ] );
		this.processQueue( NEXT_TRANSITION );
		return;
	}
	this.fireEvent.apply( this, ["InvalidState", this.state, newState ] );
};

Fsm.prototype.processQueue = function ( type ) {
	var filterFn = type === NEXT_TRANSITION ?
	               function ( item ) {
		               return item.type === NEXT_TRANSITION && ((!item.untilState) || (item.untilState === this.state));
	               } :
	               function ( item ) {
		               return item.type === NEXT_HANDLER;
	               },
		toProcess = _.filter( this.eventQueue, filterFn, this );
	this.eventQueue = _.difference( this.eventQueue, toProcess );
	_.each( toProcess, function ( item, index ) {
		this.handle.apply( this, item.args );
	}, this );
};

Fsm.prototype.deferUntilTransition = function ( stateName ) {
	if ( this.currentActionArgs ) {
		var queued = { type : NEXT_TRANSITION, untilState : stateName, args : this.currentActionArgs };
		this.eventQueue.push( queued );
		this.fireEvent.apply( this, [ "Deferred", this.state, queued ] );
	}
};

Fsm.prototype.deferUntilNextHandler = function () {
	if ( this.currentActionArgs ) {
		var queued = { type : NEXT_TRANSITION, args : this.currentActionArgs };
		this.eventQueue.push( queued );
		this.fireEvent.apply( this, [ "Deferred", this.state, queued ] );
	}
};

Fsm.prototype.on = function ( eventName, callback ) {
	if ( !this.eventListeners[eventName] ) {
		this.eventListeners[eventName] = [];
	}
	this.eventListeners[eventName].push( callback );
};

Fsm.prototype.off = function ( eventName, callback ) {
	if ( this.eventListeners[eventName] ) {
		this.eventListeners[eventName] = _.without( this.eventListeners[eventName], callback );
	}
};

var machina = {
	Fsm : Fsm,
	bus : undefined,
	utils : utils,
	on : function ( eventName, callback ) {
		if ( !this.eventListeners[eventName] ) {
			this.eventListeners[eventName] = [];
		}
		this.eventListeners[eventName].push( callback );
	},
	off : function ( eventName, callback ) {
		if ( this.eventListeners[eventName] ) {
			this.eventListeners[eventName] = _.without( this.eventListeners[eventName], callback );
		}
	},
	fireEvent : function ( eventName ) {
		var i = 0, len, args = arguments, listeners = this.eventListeners[eventName];
		if ( listeners && listeners.length ) {
			_.each( listeners, function ( callback ) {
				callback.apply( null, slice.call( args, 1 ) );
			} );
		}
	},
	eventListeners : {
		newFsm : []
	}
};

module.exports = machina;