/* TODO: Separate Project-specific data from Source */

/* model.js is where data is stored in a standard form, whatever the serializer */

(function (ns) {

var Model = {

    _SOURCE_STATUS_EMPTY : 0,

    _SOURCE_STATUS_WAITING : 1,

    _SOURCE_STATUS_READY : 2,

    _ID_AUTO_INCREMENT : 0,

    _ID_BASE : (function(_d) {

        function pad(n){return n<10 ? '0'+n : n}

        function fillrand(n) {

            var _res = ''

            for (var i=0; i<n; i++) {

                _res += Math.floor(16*Math.random()).toString(16);

            }

            return _res;

        }

        return _d.getUTCFullYear() + '-'  

            + pad(_d.getUTCMonth()+1) + '-'  

            + pad(_d.getUTCDate()) + '-'

            + fillrand(16);

    })(new Date()),

    getUID : function() {

        var _n = (++this._ID_AUTO_INCREMENT).toString();

        while (_n.length < 4) {

            _n = '0' + _n

        }

        return "autoid-" + this._ID_BASE + '-' + _n;

    },

    regexpFromTextOrArray : function(_textOrArray, _testOnly) {

        var _testOnly = _testOnly || false;

        function escapeText(_text) {

            return _text.replace(/([\\\*\+\?\|\{\[\}\]\(\)\^\$\.\#\/])/gm, '\\$1');

        }

        var _source = 

            typeof _textOrArray === "string"

            ? escapeText(_textOrArray)

            : ns._(_textOrArray).map(escapeText).join("|");

        if (_testOnly) {

            return new RegExp( _source, 'im');

        } else {

            return new RegExp( '(' + _source + ')', 'gim');

        }

    },

    isoToDate : function(_str) {

        // http://delete.me.uk/2005/03/iso8601.html

        var regexp = "([0-9]{4})(-([0-9]{2})(-([0-9]{2})(T([0-9]{2}):([0-9]{2})(:([0-9]{2})(\.([0-9]+))?)?(Z|(([-+])([0-9]{2}):([0-9]{2})))?)?)?)?";

        var d = _str.match(new RegExp(regexp));

        var offset = 0;

        var date = new Date(d[1], 0, 1);

        if (d[3]) { date.setMonth(d[3] - 1); }

        if (d[5]) { date.setDate(d[5]); }

        if (d[7]) { date.setHours(d[7]); }

        if (d[8]) { date.setMinutes(d[8]); }

        if (d[10]) { date.setSeconds(d[10]); }

        if (d[12]) { date.setMilliseconds(Number("0." + d[12]) * 1000); }

        if (d[14]) {

            offset = (Number(d[16]) * 60) + Number(d[17]);

            offset *= ((d[15] == '-') ? 1 : -1);

        }

        offset -= date.getTimezoneOffset();

        time = (Number(date) + (offset * 60 * 1000));

        var _res = new Date();

        _res.setTime(Number(time));

        return _res;

    },

    dateToIso : function(d) {

        function pad(n){return n<10 ? '0'+n : n}  

        return d.getUTCFullYear()+'-'  

            + pad(d.getUTCMonth()+1)+'-'  

            + pad(d.getUTCDate())+'T'  

            + pad(d.getUTCHours())+':'  

            + pad(d.getUTCMinutes())+':'  

            + pad(d.getUTCSeconds())+'Z'  

    }

}

/*

 * Model.List is a class for a list of elements (e.g. annotations, medias, etc. that each have a distinct ID)

 */

Model.List = function(_directory) {

    Array.call(this);

    this.directory = _directory;

    this.idIndex = [];

    this.__events = {};

    if (typeof _directory == "undefined") {

        console.trace();

        throw "Error : new Model.List(directory): directory is undefined";

    }

}

Model.List.prototype = new Array();

Model.List.prototype.hasId = function(_id) {

    return ns._(this.idIndex).include(_id);

}

/* On recent browsers, forEach and map are defined and do what we want.

 * Otherwise, we'll use the Underscore.js functions

 */

if (typeof Array.prototype.forEach === "undefined") {

    Model.List.prototype.forEach = function(_callback) {

        var _this = this;

        ns._(this).forEach(function(_value, _key) {

            _callback(_value, _key, _this);

        });

    }

}

if (typeof Array.prototype.map === "undefined") {

    Model.List.prototype.map = function(_callback) {

        var _this = this;

        return ns._(this).map(function(_value, _key) {

            return _callback(_value, _key, _this);

        });

    }

}

Model.List.prototype.pluck = function(_key) {

    return this.map(function(_value) {

        return _value[_key];

    });

}

/* We override Array's filter function because it doesn't return an Model.List

 */

Model.List.prototype.filter = function(_callback) {

    var _this = this,

        _res = new Model.List(this.directory);

    _res.addElements(ns._(this).filter(function(_value, _key) {

        return _callback(_value, _key, _this);

    }));

    return _res;

}

Model.List.prototype.slice = function(_start, _end) {

    var _res = new Model.List(this.directory);

    _res.addElements(Array.prototype.slice.call(this, _start, _end));

    return _res;

}

Model.List.prototype.splice = function(_start, _end) {

    var _res = new Model.List(this.directory);

    _res.addElements(Array.prototype.splice.call(this, _start, _end));

    this.idIndex.splice(_start, _end);

    return _res;

}

/* Array has a sort function, but it's not as interesting as Underscore.js's sortBy

 * and won't return a new Model.List

 */

Model.List.prototype.sortBy = function(_callback) {

    var _this = this,

        _res = new Model.List(this.directory);

    _res.addElements(ns._(this).sortBy(function(_value, _key) {

        return _callback(_value, _key, _this);

    }));

    return _res;

}

/* Title and Description are basic information for (almost) all element types,

 * here we can search by these criteria

 */

Model.List.prototype.searchByTitle = function(_text) {

    var _rgxp = Model.regexpFromTextOrArray(_text, true);

    return this.filter(function(_element) {

        return _rgxp.test(_element.title);

    });

}

Model.List.prototype.searchByDescription = function(_text) {

    var _rgxp = Model.regexpFromTextOrArray(_text, true);

    return this.filter(function(_element) {

        return _rgxp.test(_element.description);

    });

}

Model.List.prototype.searchByTextFields = function(_text) {

    var _rgxp =  Model.regexpFromTextOrArray(_text, true);

    return this.filter(function(_element) {

        return _rgxp.test(_element.description) || _rgxp.test(_element.title);

    });

}

Model.List.prototype.getTitles = function() {

    return this.map(function(_el) {

        return _el.title;

    });

}

Model.List.prototype.addId = function(_id) {

    var _el = this.directory.getElement(_id)

    if (!this.hasId(_id) && typeof _el !== "undefined") {

        this.idIndex.push(_id);

        Array.prototype.push.call(this, _el);

    }

}

Model.List.prototype.push = function(_el) {

    if (typeof _el === "undefined") {

        return;

    }

    var _index = (ns._(this.idIndex).indexOf(_el.id));

    if (_index === -1) {

        this.idIndex.push(_el.id);

        Array.prototype.push.call(this, _el);

    } else {

        this[_index] = _el;

    }

}

Model.List.prototype.addIds = function(_array) {

    var _l = _array.length,

        _this = this;

    ns._(_array).forEach(function(_id) {

        _this.addId(_id);

    });

}

Model.List.prototype.addElements = function(_array) {

    var _this = this;

    ns._(_array).forEach(function(_el) {

        _this.push(_el);

    });

}

Model.List.prototype.removeId = function(_id, _deleteFromDirectory) {

    var _deleteFromDirectory = _deleteFromDirectory || false,

        _index = (ns._(this.idIndex).indexOf(_id));

    if (_index !== -1) {

        this.splice(_index,1);

    }

    if (_deleteFromDirectory) {

        delete this.directory.elements[_id];

    }

}

Model.List.prototype.removeElement = function(_el, _deleteFromDirectory) {

    var _deleteFromDirectory = _deleteFromDirectory || false;

    this.removeId(_el.id);

}

Model.List.prototype.removeIds = function(_list, _deleteFromDirectory) {

    var _deleteFromDirectory = _deleteFromDirectory || false,

        _this = this;

    ns._(_list).forEach(function(_id) {

        _this.removeId(_id);

    });

}

Model.List.prototype.removeElements = function(_list, _deleteFromDirectory) {

    var _deleteFromDirectory = _deleteFromDirectory || false,

        _this = this;

    ns._(_list).forEach(function(_el) {

        _this.removeElement(_el);

    });

}

Model.List.prototype.on = function(_event, _callback) {

    if (typeof this.__events[_event] === "undefined") {

        this.__events[_event] = [];

    }

    this.__events[_event].push(_callback);

}

Model.List.prototype.off = function(_event, _callback) {

    if (typeof this.__events[_event] !== "undefined") {

        this.__events[_event] = ns._(this.__events[_event]).reject(function(_fn) {

            return _fn === _callback;

        });

    }

}

Model.List.prototype.trigger = function(_event, _data) {

    var _list = this;

    ns._(this.__events[_event]).each(function(_callback) {

        _callback.call(_list, _data);

    });

}

/* A simple time management object, that helps converting millisecs to seconds and strings,

 * without the clumsiness of the original Date object.

 */

Model.Time = function(_milliseconds) {

    this.milliseconds = 0;

    this.setMilliseconds(_milliseconds);

}

Model.Time.prototype.setMilliseconds = function(_milliseconds) {

    var _ante = _milliseconds;

    switch(typeof _milliseconds) {

        case "string":

            this.milliseconds = parseFloat(_milliseconds);

            break;

        case "number":

            this.milliseconds = _milliseconds;

            break;

        case "object":

            this.milliseconds = parseFloat(_milliseconds.valueOf());

            break;

        default:

            this.milliseconds = 0;

    }

    if (this.milliseconds === NaN) {

        this.milliseconds = _ante;

    }

}

Model.Time.prototype.setSeconds = function(_seconds) {

    this.milliseconds = 1000 * _seconds;

}

Model.Time.prototype.getSeconds = function() {

    return this.milliseconds / 1000;

}

Model.Time.prototype.getHMS = function() {

    var _totalSeconds = Math.abs(Math.floor(this.getSeconds()));

    return {

        hours : Math.floor(_totalSeconds / 3600),

        minutes : (Math.floor(_totalSeconds / 60) % 60),

        seconds : _totalSeconds % 60

    } 

}

Model.Time.prototype.add = function(_milliseconds) {

    this.milliseconds += new Model.Time(_milliseconds).milliseconds;

}

Model.Time.prototype.valueOf = function() {

    return this.milliseconds;

}