var NanoFlux = require('nanoflux-fusion');
	
	// NanoFlux provides a dedicated store
	var fusionStore = NanoFlux.getFusionStore();
	
	// subscription is the same as in NanoFlux, note that the function passes a state (which is immutable)
	var subscription = fusionStore.subscribe(this, function(state){
		// ... do something with the state
		// state is also available via fusionStore.getState()
		console.log("Items:", state.items);
	});
	
	// the 'fusionator' is responsible for the state manipulation
	// it is called with two arguments, the previous state
	// and an arguments array containing the arguments passed on actor call.
	NanoFlux.createFusionator({
		
		addItem : function(previousState, args){
			// the previous state is frozen/immutable, so we need to copy the items to update the list
			var currentItems = previousState.items.slice(); 
			currentItems.push(args[0]);
			// we don't need to return the entire state. 
			// A partial state will be merged
			// As builtin feature, the new state is being frozen (deeply)
			return { items : currentItems };
		},
		removeItem : function(previousState, args){
			if (previousState.items.length == 0) return {};

			// note: filter creates a copy already 
			var items = previousState.items.filter(function (item) {
				return item.name !== args[0];
			});
			return {items: items}
		}
	}, 
	// define an initial state!
	{
	 items: []	
	});
	
	// gets the fusion actors, i.e. have the same name as defined above
	var addItem = NanoFlux.getFusionActor("addItem");
	var removeItem = NanoFlux.getFusionActor("removeItem");
	
	// use the actors as simple action functions
	addItem({ name: "item1", value : 1 });
	addItem({ name: "item2", value : 2 });
	
	removeItem("item1");

function asyncA(arg1){
	return new Promise(function(resolve,reject){
		setTimeout(function(){
			// returns state to be merged
			resolve({a: arg1});
		}, 500)
	})
}
 
function asyncB(arg1){
	return new Promise(function(resolve,reject){
		setTimeout(function(){
			resolve( { b: 5 + arg1.a });
		}, 500)
	})
}

var asyncFusionator = NanoFlux.createFusionator({
	
	simplePromise: function(prevState, args){
			return asyncA(args[0]); 
	},	
	chainedPromises: function(prevState, args){
		return asyncA(args[0]).then(function(data){
			console.log(data); // data = {a: 5} 
			return asyncB(data);  
		});
	}
}, 
// initial state
{
	a: 0,
	b: 0
});

var simplePromise = NanoFlux.getFusionActor("simplePromise");
var chainedPromises = NanoFlux.getFusionActor("chainedPromises");

// call the actions
simplePromise(5); // state will be { a: 5 }
chainedPromises(5); // state will be { a: 5, b: 10 }

function LoggerMiddleware(){
	var logData = [];

	this.log = function(newState, oldState, actionName){
		logData.push({
		    action: actionName,
		    timestamp: Date.now(),
			state: _.cloneDeep(oldState)
		});

		return newState; // must return a state 
	};

	this.countLogEntries = function(){ return logData.length };
	this.getLogEntry = function(t){
		return logData[t];
	};
}

var fusionStore = NanoFlux.getFusionStore();
var logger = new LoggerMiddleware();
fusionStore.use( logger.log );
// use more if needed ... 

function addTimestamp(newState, oldState){

		var modifiedState = {};
		modifiedState.modified = Date.now();

		Object.assign(newState, modifiedState);
		return newState;
}

fusionStore.use( addTimestamp );