angular.module('Andalay', ['underscore']).factory('Andalay', ['$http', '$q', '$parse', '_',
	function($http ,  $q ,  $parse, _) {
	'use strict';

	var Andalay = {};

new Andalay.Model({name:'steve'});

Andalay.Model = function(attributes, options) {
	// extend the model with default properties, override defaults if specified in attributes
	var attrs = attributes || {};
	options = options || {};
	// give the model an autogenerated client id
	this.cid = _.uniqueId('c');
	if (options.parse) attrs = this.parse(attrs, options) || {};
	attrs = _.defaults({}, attrs, angular.copy(_.result(this, 'defaults')));
	if (attrs) {
		angular.extend(this, attrs);
	}
	this.initialize.apply(this, arguments);
};

Andalay.Model.prototype = {

idAttribute: 'id',

loading: false,

saving: false,

defaults: {},

initialize: function() {},

toJSON: function() {
	var json = angular.copy(this);
	delete json.collection;
	delete json.cid;
	return json;
},

has: function(property){
	return angular.isDefined(this[property]);
},

parse: function(response, options) {
	return response;
},

isNew: function() {
	return !this.has(this.idAttribute);
},

isValid: function() {
	return this.validate();
},

url: function() {
	var base =
	  _.result(this, 'urlRoot') ||
	  _.result(this.collection, 'url') ||
	  urlError();
	if (this.isNew()) return base;
	var id = this.id || this[this.idAttribute];
	return base.replace(/([^\/])$/, '$1/') + encodeURIComponent(id);
},

validate: function() {
	return true;
},

sync: function() {
	return Andalay.sync.apply(this, arguments);
},

fetch: function (options) {
	options = options ? _.clone(options) : {};
	if (options.parse === void 0) {
		options.parse = true;
	}
	var model = this;
	model.loading = true;
	return this.sync('read', this, options).then(function(response){
		model.loading = false;
		var data = options.parse ? model.parse(response.data) : response.data;
		angular.extend(model, data);
	}, function(err){
		throw new Error('Error retrieving model');
	});
},

save: function(options){
	var method = this.isNew() ? 'create' : 'update';
	options = _.defaults((options || {}), {validate:true});
	this.setSaving(true);
	var deferred = $q.defer();
	if (options.validate && !this.validate()) {
		deferred.reject('Validation failed');
	}
	var model = this;
	return this.sync(method, this, options).then(function(response) {
		// Success
		model.setSaving(false);
		angular.extend(model, model.parse(response.data));
		deferred.resolve(response);
	}, function(response){
		// Error, assumes if request fails the returned data is an array of errors.
		// In the format [{attribute:['error message']}]
		model._errors = response.data;
		deferred.reject(response);
	});
},

delete: function() {
	var model = this;
	model.loading = true;
	return this.sync('delete', this).then(function(response){
		model.loading = false;
		if (angular.isDefined(model.collection)) {
			model.collection.remove(model.id);
		}
		model[model.idAttribute] = null;
	}, function(err){
		throw new Error('Error deleting model');
	});
},

// Store errors
_errors:{},

setSaving: function(isSaving) {
	this.saving = isSaving;
	if (this.collection) {
		this.collection.saving = isSaving;
	}
}
	};
	
	// Add additional relevent underscore methods to the Model.
	var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit', 'chain', 'isEmpty'];
	_.each(modelMethods, function(method) {
if (!_[method]) return;
Andalay.Model.prototype[method] = function() {
	var args = [].slice.call(arguments);
	args.unshift(this);
	return _[method].apply(_, args);
};
	});

Andalay.Collection = function(models, options) {
	options = options || {};
	if (options.model) this.model = options.model;
	this._reset();
	this.initialize.apply(this, arguments);
	if (models) this.reset(models);
};

Andalay.Collection.prototype = {

model: Andalay.Model,

loading:false,

saving: false,

models: [],

_index:{},

length: 0,

initialize: function(properties, options) {},

toJSON: function() {
	var json = [];
	this.forEach(function(model, index) {
		json.push(model.toJSON());
	});
	return json;
},

addOne: function(obj, options) {
	var id, existing, index;
	options = options || {};
	if (_.isArray(obj))
		throw new Error('The object to add must be an object. Array given');
	if (!_.isObject(obj)){
		throw new Error('Cannot add "' + obj + '" to the collection. You must specify an object to add');
	}
	index = (options.at !== void 0) ? options.at : this.models.length;
	var model = this.get(obj);
	if (this.exists(obj)) {
		// already exists in the collection so extend it.
		angular.extend(model, obj);
	} else {
		// add a new one
		model = this._prepareModel(obj);
		this._addReference(model);
		// add the model to the models array
		this.models.splice(index, 0, model);
		this.length += 1;
	}
	return model;
},

parse: function(response, options) {
	return response;
},

var myCollection = Collection.addMany([{name:'test object'},{name:'another test object'}])

addMany: function(models) {
	if (!_.isArray(models)) {
		throw new Error('Cannot add ' + models + ', models must be an array of objects');
	}
	var added = [];
	for (var i = 0; i < models.length; i++) {
		var obj = models[i];
		added.push(this.addOne(obj));
	}
	return added;
},

updateMany: function(models) {
	return this.addMany(models);
},

reset: function (models) {
	this._reset();
	if (models)
		return this.addMany(models);
	return [];
},

get: function(obj) {
	// Must specify a valid object or id.
	// Allow ids of value 0.
	if (!obj && obj !== 0) return void 0;
	return this._index[obj] || this._index[this.modelId(obj)] || this._index[obj.cid];
},

exists: function(id) {
	return !angular.isUndefined(this.get(id));
},

update: function(model) {
	return this.addOne(model);
},

remove: function(id) {
	var model = this.get(id);
	if (_.isUndefined(model)) {
		return void 0;
	}
	this._removeReference(model);
	var index = _.indexOf(this.models, model);
	this.models.splice(index, 1);
	this.length--;
	return model;
},

removeAll: function() {
	this.reset();
	return this;
},

modelId: function (object) {
	return object[this.model.prototype.idAttribute || 'id'];
},

last: function() {
	return this.models[this.length-1];
},

at: function(index) {
	return this.models[index];
},

size: function() {
	return this.models.length;
},

all: function() {
	return this.models;
},

where: function (attrs, first) {
	var matches = _.matches(attrs);
	return this[first ? 'find' : 'filter'](function (model) {
		return matches(model);
	});
},

findWhere: function (attrs) {
	return this.where(attrs, true);
},

sync: function() {
	return Andalay.sync.apply(this, arguments);
},

fetch: function (options) {
	options = options ? _.clone(options) : {};
	if (options.parse === void 0) {
		options.parse = true;
	}
	var collection = this;
	collection.loading = true;
	return this.sync('read', this, options).then(function(response){
		collection.loading = false;
		var data = options.parse ? collection.parse(response.data) : response.data;
		collection.addMany(data);
	}, function(){
		// error
	});
},

_reset: function() {
	this.length = 0;
	this.models = [];
	this._index = {};
},

_prepareModel: function(object) {
	var model = object;
	if (object instanceof Andalay.Model) {
		model = object;
	} else {
		model = new this.model(object);
	}
	model.collection = this;
	return model;
},

_addReference: function(model) {
	this._index[model.cid] = model;
	var id = this.modelId(model);
	if (angular.isDefined(id) && id !== null) {
		this._index[id] = model;
	}
},

_removeReference: function(model) {
	delete this._index[model.cid];
	var id = this.modelId(model);
	if (angular.isDefined(id) && id !== null) {
		delete this._index[id];
	}
}

	};

	var methods = ['forEach', 'each', 'find', 'filter'];

	// Additional relevant underscore functions to add:
	// 'map', 'collect', 'reduce', 'foldl',
	// 'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',
	// 'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',
	// 'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
	// 'tail', 'drop', 'last', 'without', 'difference', 'indexOf', 'shuffle',
	// 'lastIndexOf', 'isEmpty', 'chain', 'sample', 'partition'
	_.each(methods, function(method) {
if (!_[method]) return;
Andalay.Collection.prototype[method] = function() {
	var args = [].slice.call(arguments);
	args.unshift(this.models);
	return _[method].apply(_, args);
};
	});

Andalay.sync = function(method, model, options) {
	var methodMap = {
		'create': 'POST',
		'update': 'PUT',
		'patch': 'PATCH',
		'delete': 'DELETE',
		'read': 'GET'
	};
	options = options || {};
	var params = {method: methodMap[method]};
	// Ensure that we have a URL.
	if (angular.isUndefined(options.url)) {
		params.url = _.result(model, 'url') || urlError();
	}
	if (_.isUndefined(options.data) && model && (method === 'create' || method === 'update' || method === 'patch')) {
		params.data = model.toJSON();
	}
	var httpOptions = angular.extend(params, options);
	model.saving = true;
	return $http(httpOptions);
};

var extend = function(protoProps, staticProps) {
	var parent = this;
	var child;
	if (protoProps && _.has(protoProps, 'constructor')) {
		child = protoProps.constructor;
	} else {
		child = function(){ return parent.apply(this, arguments); };
	}
	// Add static properties to the constructor function, if supplied.
	_.extend(child, parent, staticProps);
	// Set the prototype chain to inherit from parent, without calling parent‘s constructor function.
	var Surrogate = function () { this.$constructor = child; };
	Surrogate.prototype = parent.prototype;
	child.prototype = new Surrogate();
	// Add prototype properties (instance properties) to the subclass, if supplied.
	if (protoProps) _.extend(child.prototype, protoProps);
	// Set a convenience property in case the parent’s prototype is needed later.
	child.__super__ = parent.prototype;
	return child;
};

var urlError = function() {
	throw new Error('A "url" property or function must be specified in the collection. If the model is not added to a collection it should have a urlRoot property');
};

Andalay.Model.extend = Andalay.Collection.extend = extend;

return Andalay;
}]);