Db = function() {

  //initial comment db as objs (TREE LIKE MODEL : replies are included in comment.replies)

  this.comments = null; // current set of (filtered) comments 

  this.allComments = null; // all server database comments

  // obj

  // keys : commentDbId as string 

  // values : comment db as obj

  this.commentsByDbId = {};

  this.allCommentsByDbId = {};

  // dictionary (always contains all comments (no reply) whatever the filter

  // order key --> ordered array of comment ids (no reply)

  this.ordered_comment_ids = {}; // all server database comments

}

Db.prototype = {

//////////////////////////////

//    CORE FUNCTIONS

//////////////////////////////

  init : function() {

    // at first server side ordered comment by asc ids, replies by creation date :

    this.allComments = CY.JSON.parse(sv_comments) ;

    if (sv_read_only) {

      this.initToReadOnly() ;

    }

      this._computeAllCommentsByDbId() ;

      this._reorder() ;

  },

  _del : function (arr, dic, id) {

    // first recursively remove all replies

    var comment = dic[id] ;

    for (var i = 0 ; i < comment.replies.length ; i++) {

      var rid = comment.replies[i].id ;

      this._del(comment.replies, dic, rid) ;

      i--;

    }

    for (var i = 0, ilen = arr.length ; i < ilen ; i++) {

      if (arr[i].id == id) {

        arr.splice(i, 1) ;

        delete dic[id] ;

        break ;

      }

    }

  },

  del : function(comment) {

    var arr = (comment.reply_to_id == null) ? this.comments : this.commentsByDbId[comment.reply_to_id].replies ; 

    this._del(arr, this.commentsByDbId, comment.id) ;

    arr = (comment.reply_to_id == null) ? this.allComments : this.allCommentsByDbId[comment.reply_to_id].replies ; 

    this._del(arr, this.allCommentsByDbId, comment.id) ;

    this._reorder() ;

  },

  // maintains the ordered lists

  _reorder : function() {

    // scope (order by start_wrapper, start_offset, end_wrapper, end_offset 

    var a = [] ;

    for (var i = 0, ilen = this.allComments.length ; i < ilen ; i++) {

      var comment = this.allComments[i] ;

      var found = false ;

      for (var j = 0, jlen = a.length ; j < jlen ; j++) {

        var id = a[j] ;

        var comment2 = this.allCommentsByDbId[id] ;

        if ((comment.start_wrapper < comment2.start_wrapper)

          ||

          ((comment.start_wrapper == comment2.start_wrapper) && (comment.start_offset < comment2.start_offset) )

          ||

          ((comment.start_wrapper == comment2.start_wrapper) && (comment.start_offset == comment2.start_offset) && (comment.end_wrapper < comment2.end_wrapper) ) 

          ||

          ((comment.start_wrapper == comment2.start_wrapper) && (comment.start_offset == comment2.start_offset) && (comment.end_wrapper == comment2.end_wrapper) && (comment.end_offset < comment2.end_offset) ) ) {

            a.splice(j, 0, comment.id) ;

            found = true ;

            break ;

          }

      }

      if (!found)  {

        a.push(comment.id) ;

      }

    }

    this.ordered_comment_ids['scope']  = a ;

    // modified thread  

    a = [] ;

    var mod = {} ; // we'll aggregate modification dates in this assoc array id --> latest modification

    for (var i = 0, ilen = this.allComments.length ; i < ilen ; i++) {

      var comment = this.allComments[i] ;

      var commentModif = comment.modified ;

      mod[comment.id] = this._latest_mod(comment);

    }

    for (var id in mod) {

      var numberId = this.allCommentsByDbId[id].id      

      var found = false ;

      for (var i = 0, ilen = a.length ; i < ilen ; i++) {

        var id2 = a[i] ;

        if (mod[id] < mod[id2]) {

          a.splice(i, 0, numberId) ;

          found = true ;

          break ;

        }

      }

      if (!found)  {

        a.push(numberId) ;

      }

    }

    this.ordered_comment_ids['modif_thread'] = a ; 

  },

   // Finds recursively the last modification date of a thread.

  _latest_mod : function(comment) {

    var latest_mod = comment.modified;

    for (var i=0; i<comment.replies.length; i++) {

      var reply = comment.replies[i] ;

      var reply_mod = this._latest_mod(reply);

      if (reply_mod > latest_mod)

        latest_mod = reply_mod;

    }

    return latest_mod;

  },

  // EDIT OR ADD CASE : when just added id is max and so both (comments and replies) initial id asc order remains

  _upd : function(arr, dic, c) {

    var found = false ;

    for (var i = 0, ilen = arr.length ; i < ilen ; i++) {

      if (arr[i].id == c.id) { // edit

        arr.splice(i, 1, c) ;

        found = true ;

        break ;

      }

    }

    if (!found) { // add

      arr.push(c) ;

    }

    dic[c.id] = c ;

  },

  // EDIT OR ADD CASE : when just added id is max and so both (comments and replies) initial id asc order respected

  upd : function(comment) {

    var arr = (comment.reply_to_id == null) ? this.allComments : this.allCommentsByDbId[comment.reply_to_id].replies ; 

    this._upd(arr, this.allCommentsByDbId, comment) ;

    var cloneComment = CY.clone(comment) ;

    arr = (comment.reply_to_id == null) ? this.comments : this.commentsByDbId[comment.reply_to_id].replies ; 

    this._upd(arr, this.commentsByDbId, cloneComment) ;

    this._reorder() ;   

  },

  // initializes this.comments

  // commentId is the result of a computeFilterResults call : no assumption can be made on the order of ids (!)

  // so we'll loop through allComments to carry order from allComments to comments

  initComments : function(commentIds) {

      this.comments = [] ;

    for (var i = 0, ilen = this.allComments.length ; i < ilen ; i++) {

      var index = CY.Array.indexOf(commentIds, this.allComments[i].id) ;

      if (index != -1) {

        var cloneComment = CY.clone(this.allComments[i]) ;

        this.comments.push(cloneComment) ;

      }

    }

      this._computeCommentsByDbId() ;

  },

  _computeCommentsByDbId : function() {

    this.commentsByDbId = {} ;

      var flatComments = this.getThreads(this.comments) ;

    for ( var i = 0; i < flatComments.length; i++)

      this.commentsByDbId[flatComments[i].id] = flatComments[i];

  },

  _computeAllCommentsByDbId : function() {

    this.allCommentsByDbId = {} ;

      var flatComments = this.getThreads(this.allComments) ;

    for (var i = 0; i < flatComments.length; i++) 

      this.allCommentsByDbId[flatComments[i].id] = flatComments[i];

  },

  // returns threads :

  // given an array [comment1, comment2, comment3], this function will return [comment1, comment1reply1, comment1reply1reply1, comment1reply1reply2, comment2, comment3, comment3reply1]

  //note : will return top parents ordered the way comments are

  getThreads : function(comments) {

    var ret = [] ;

    for (var i = 0 ; i < comments.length ; i++) {

      ret.push(comments[i]) ;

      if (comments[i].replies.length > 0)

        ret = ret.concat(this.getThreads(comments[i].replies)) ;

    }

    return ret ;

  },

  _getPath : function(dic, comment) {

    var ret = [comment] ;

    var c = comment ;

    while (c.reply_to_id != null) {

      c = dic[c.reply_to_id] ;

      ret.push(c) ;

    }

    return ret ;

  },

  // returns comments as array : [comment, ..., comment's top parent]

  getPath : function(comment) {

    return this._getPath(this.commentsByDbId, comment) ;

  },

  // getCommentFromIComment ...

  getComment : function(dbId) {

    return this.commentsByDbId[dbId] ;

  },  

  getCommentByIdKey : function(id_key) {

    for (var id in this.commentsByDbId) {

      var comment = this.commentsByDbId[id] ;

      if (comment.id_key == id_key) { 

        return comment ;

      }

    }

    return null ;

  },  

  isChild : function(commentDbId, parentDbId) {

    var comment = this.commentsByDbId[commentDbId] ;

    var isChild = (commentDbId == parentDbId) ;

    while ((!isChild) && (comment.reply_to_id != null)) {

      comment = this.commentsByDbId[comment.reply_to_id] ;

      isChild = (comment.id == parentDbId) ; ;

    }

    return isChild ;

  },  

  initToReadOnly : function(commentDbId, parentDbId) {

    for (var i = 0, ilen = this.allComments.length ; i < ilen ; i++) {

      var comment = this.allComments[i] ;

      for (var prop in comment) {

        if (0 == prop.indexOf("can_") && typeof comment[prop] === 'boolean')

          comment[prop] = false ;

      }

    }

  },  

//////////////////////////////

//  BROWSING FUNCTIONS

//////////////////////////////

  browsingIndex : function(dbId) {

    var indx = {} ;

    for (var order in this.ordered_comment_ids) {

      var inFilter =  CY.Array.filter(this.ordered_comment_ids[order], function(id) {return (id in this.commentsByDbId);}, this) ;

      indx[order] = CY.Array.indexOf(inFilter, dbId ) ;

    }

    //indx['total'] = this.ordered_comment_ids['scope'].length

    return indx ;

  },

  browse : function(order, whereto, dbId) {

    //var arr = this.ordered_comment_ids[gConf['defaultBrowsingOrder']] ;

//    CY.log(order) ;

    var arr = this.ordered_comment_ids[order] ;

    if (arr.length > 0) {

      var starti = -1 ; 

      if ((whereto == 'prev') || (whereto == 'next')) {

        for (var i = 0 ; i < arr.length ; i++) {

          var id = arr[i] ;

          if (id == dbId) {

            starti = (whereto == 'prev') ? i - 1 : i + 1 ;

            starti = (arr.length + starti) % arr.length ; // to guaranty a positive value 

            break ;

          }

        }

        if (starti == -1) {

          CY.error("internal error in db browse (was called with a dbId that isn't among the filtered ones)") ;

          return null;

        }

      }

      if (whereto == 'last') {

        starti = arr.length - 1 ;

      }

      if (whereto == 'first') {

        starti = 0 ;

      }

      for (var i = starti, j = 0 ; (i >= 0) && (i < arr.length) ; j++ ) {