var TestModel = Backbone.Model.extend({
   validators: {
       title: {
           fn: function(value){
               if(typeof(value) !== 'string'){
                   return "The title has to be a valid string";
               }
           }
       }
   }
});

var test_model = new TestModel();
test_model.set({title: "I am a title!"});
test_model.get('title');
"I am a title!"
test_model.set({title: false});
test_model.get('title');
"I am a title!"

TestModel.extend({
    initialize: function(){
        this.on('error', this.display_error);
    },
    display_error: function(model, error){
        console.log(error);
    }
});

var test_model = new TestModel();
test_model.set({title: "I am a title!"});
test_model.get('title');
"I am a title!"
test_model.set({title: false});
"The title has to be a valid string"
test_model.get('title');
"I am a title!" 

TestModel.extend({
    use_defaults: true,
    defaults: {
        title: "BAD TITLE"
    }
});

var test_model = new TestModel();
test_model.set({title: "I am a title!"});
test_model.get('title');
"I am a title!"
test_model.set({title: false});
"The title has to be a valid string"
test_model.get('title');
"BAD TITLE"

TestModel.validators.extend({
    title: {
        is_type: 'string',
        max_length: 40
    }
});

var t = new TestModel();
t.set({title: 'this is a new title'});
t.get('title');
"this is a new title"
t.set({title: false});
"Expected false to be of type string"
t.get('title');
"this is a new title"    
t.set({title: 'this title is way too long to be set and it should not get set because it is way too long and like if it gets set it will suck because this is way too long'});
"Attribute value was longer than 40 characters"
t.get('title');    
"this is a new title"

_.extend(Backbone.Validator.testers, {
    no_hotdogs_without_mustard: function(value, mustard, attribute){
        if(value.indexOf('hotdogs') > -1 && mustard === false){
            return format('{0} MAY NOT BE A HOTDOG WITHOUT MUSTARD!', attribute);
        }
    }
});

// does the value exist within a given range, inclusive
range: function(value, range, attribute){
    if(_.isArray(range) && range.length === 2){
        if((value <= range[0]) || (value >= range[1])){
            return format('{0} is not within the range {1} - {2} for {3}', value, range[0], range[1], attribute)
        }
    }
},

// if type is date we'll do something different.
// also, (Underscore: add `_.isValidDate`)[https://github.com/documentcloud/underscore/pull/489] means we're not going to use _.isDate
// and since this is generic we can't use our forked version
is_type: function(value, type, attribute){
    if(type === 'date'){
        if(_.isNaN(value.valueOf()) || toString.call(value) != '[object Date]'){
            return format("Expected {0} to be a valid date for {1}", value, attribute);
        }
    } else {
        if(typeof(value) !== type){
            return format("Expected {0} to be of type {1} for {2} ", value, type, attribute);
        }
        
    }            
},

// Does it pass a regular expression test
regex: function(value, re, attribute){
    var regex = new RegExp(re);
    if(regex.test(value)){
        return format("{0} did not match pattern {1} for {2}", value, regex.toString(), attribute);
    }
},

// is it present in a given list
in_list: function(value, list, attribute){
    if(_.isArray(list) && list.indexOf(value) === -1){
        return format("{0} is not part of [{1}] for {2}", value, list.join(', '), attribute);
    }
},

// is a key of an object
is_key: function(value, obj, attribute){
    if(_.has(obj, value)){
        return format("{0} is not one of [{1}] for {2}", value, _(obj).keys().join(', '), attribute);
    }
},

// does the value come in under a max?
max_length: function(value, length, attribute){
    if(!_.isNull(value) && !_.isUndefined(value) && _.has(value, "length") && !_.isUndefined(value.length) && (value.length > length)){
        return format("{0} is longer than {1} for {2} ", value, length, attribute);
    }
},

// does the value meet a minimum requirement
min_length: function(value, length, attribute){
    if(!_.isNull(value) && !_.isUndefined(value) && _.has(value, "length") && !_.isUndefined(value.length) && (value.length < length)){
        return format('{0} is shorter than {1} for {2}', value, length, attribute);
    }
},

// are they the same
to_equal: function(value, example, attribute){
    if(!_.isEqual(value, example)){
        return format("{0} is not the same as {1} for {2}", value, example, attribute);
    }
},

// unbounded top 
min_value: function(value, limit, attribute){
    if(value < limit){
        return format("{0} is smaller than {1} for {2}", value, limit, attribute);
    }
},

// unbounded bottom
max_value: function(value, limit, attribute){
    if(value > limit){
        return format("{0} exceeds {1} for {2}", value, limit, attribute);
    }
}

// is an instance of an object
is_instance: function(value, type){
    if(!(value instanceof type)){
        return format("{0} is not an instance of {1}", value, type);
    }
}