def get_thread(self, id):
        thread = None
        parent = None

        if isinstance(id, Thread):
            thread = id
            id = thread.id

        thread_id = url2id(id, nopost=True) or id
        try:
            last_seen_id = self.storage.get('seen', default={})[id2topic(thread_id)]
        except KeyError:
            last_seen_id = 0

        with self.browser:
            for post in self.browser.iter_posts(id):
                if not thread:
                    thread = Thread(thread_id)
                    thread.title = post.title

                m = self._post2message(thread, post)
                m.parent = parent
                if last_seen_id < post.id:
                    m.flags |= Message.IS_UNREAD

                if parent:
                    parent.children = [m]
                else:
                    thread.root = m

                parent = m

        return thread

    def get_thread(self, id, entry=None):
        if isinstance(id, Thread):
            thread = id
            id = thread.id
        else:
            thread = Thread(id)

        if entry is None:
            entry = Newsfeed(self.config['url'].get()).get_entry(id)
        if entry is None:
            return None

        flags = Message.IS_HTML
        if not thread.id in self.storage.get('seen', default=[]):
            flags |= Message.IS_UNREAD
        if len(entry.content) > 0:
            content = u"<p>Link %s</p> %s" % (entry.link, entry.content[0])
        else:
            content = entry.link

        thread.title = entry.title
        thread.root = Message(thread=thread,
                              id=0,
                              title=entry.title,
                              sender=entry.author,
                              receivers=None,
                              date=entry.datetime,
                              parent=None,
                              content=content,
                              children=[],
                              flags=flags)
        return thread

    def get_thread(self, _id):
        thread = Thread(_id)
        thread.title = 'Mail for %s' % _id
        thread.flags = thread.IS_DISCUSSION

        self._get_messages_thread(_id, thread)
        return thread

 def get_thread(self, id):
     thr = Thread(id=id)
     self.fill_thread(thr)
     thr.date = thr.root.date
     thr.title = thr.root.title
     thr.url = thr.root.url
     return thr

 def iter_threads(self):
     for thread in self.browser.get_threads():
         t = Thread(thread['id'])
         t.flags = Thread.IS_DISCUSSION
         t.title = u'Discussion with %s' % thread['name']
         t.date = local2utc(datetime.datetime.fromtimestamp(thread['last_message']['utc_timestamp']))
         yield t

 def iter_threads(self):
     table = self.parser.select(self.document.getroot(), "table#listeMessages", 1)
     for tr in table.xpath("./tr"):
         if tr.attrib.get("class", "") not in ("msgLu", "msgNonLu"):
             continue
         author = unicode(self.parser.select(tr, "td.colEmetteur", 1).text)
         link = self.parser.select(tr, "td.colObjet a", 1)
         date_raw = self.parser.select(tr, "td.colDate1", 1).attrib["data"]
         jsparams = re.search("\((.+)\)", link.attrib["onclick"]).groups()[0]
         jsparams = [i.strip("'\" ") for i in jsparams.split(",")]
         page_id, _id, unread = jsparams
         # this means unread on the website
         unread = False if unread == "false" else True
         # 2012/02/29:01h30min45sec
         dt_match = re.match("(\d+)/(\d+)/(\d+):(\d+)h(\d+)min(\d+)sec", date_raw).groups()
         dt_match = [int(d) for d in dt_match]
         thread = Thread(_id)
         thread._link_id = (page_id, unread)
         thread.date = datetime(*dt_match)
         thread.title = unicode(link.text)
         message = Message(thread, 0)
         message.set_empty_fields(None)
         message.flags = message.IS_HTML
         message.title = thread.title
         message.date = thread.date
         message.sender = author
         message.content = NotLoaded  # This is the only thing we are missing
         thread.root = message
         yield thread

 def get_thread(self, id):
     if isinstance(id, Thread):
         thread = id
         id = thread.id
     else:
         thread = Thread(id)
     entry = Newsfeed(self.config["url"]).get_entry(id)
     flags = Message.IS_HTML
     if not thread.id in self.storage.get('seen', default=[]):
         flags |= Message.IS_UNREAD
     if len(entry.content):
         content = entry.content[0]
     else:
         content = None
     thread.title = entry.title
     thread.root = Message(thread=thread,
                           id=0,
                           title=entry.title,
                           sender=entry.author,
                           receivers=None,
                           date=entry.datetime,
                           parent=None,
                           content=content,
                           children=[],
                           flags=flags)
     return thread

    def iter_unread_messages(self):
        with self.browser:
            url = self.browser.get_root_feed_url()
            for article in Newsfeed(url, rssid).iter_entries():
                id = url2id(article.link)
                thread = None

                try:
                    last_seen_id = self.storage.get('seen', default={})[id2topic(id)]
                except KeyError:
                    last_seen_id = 0

                child = None
                iterator = self.browser.riter_posts(id, last_seen_id)
                if self.config['thread_unread_messages'].get() > 0:
                    iterator = limit(iterator, self.config['thread_unread_messages'].get())
                for post in iterator:
                    if not thread:
                        thread = Thread('%s.%s' % (post.forum_id, post.topic_id))
                    message = self._post2message(thread, post)

                    if child:
                        message.children.append(child)
                        child.parent = message

                    if post.parent:
                        message.parent = Message(thread=thread,
                                                 id=post.parent)
                    else:
                        thread.root = message
                    yield message

 def iter_threads(self):
     with self.browser:
         for story in self.browser.iter_stories():
             thread = Thread(story.id)
             thread.title = story.title
             thread.date = story.date
             yield thread

    def iter_unread_messages(self):
        try:
            contacts = {}
            with self.browser:
                threads = self.browser.get_threads_list()
            for thread in threads:
                #if thread['member'].get('isBan', thread['member'].get('dead', False)):
                #    with self.browser:
                #        self.browser.delete_thread(int(thread['member']['id']))
                #    continue
                if self.antispam and not self.antispam.check_thread(thread):
                    self.logger.info('Skipped a spam-unread-thread from %s' % thread['who']['pseudo'])
                    self.report_spam(thread['member']['id'])
                    continue
                slut = self._get_slut(thread['who']['id'])
                if parse_dt(thread['date']) > slut['lastmsg'] or thread['status'] != slut['status']:
                    t = self.get_thread(thread['who']['id'], contacts, get_profiles=True)
                    for m in t.iter_all_messages():
                        if m.flags & m.IS_UNREAD:
                            yield m

            if not self.config['baskets'].get():
                return

            # Send mail when someone added me in her basket.
            # XXX possibly race condition if a slut adds me in her basket
            #     between the aum.nb_new_baskets() and aum.get_baskets().
            with self.browser:
                slut = self._get_slut(-self.MAGIC_ID_BASKET)

                new_baskets = self.browser.nb_new_baskets()
                if new_baskets > 0:
                    baskets = self.browser.get_baskets()
                    my_name = self.browser.get_my_name()
                    for basket in baskets:
                        if parse_dt(basket['date']) <= slut['lastmsg']:
                            continue
                        contact = self.get_contact(basket['who']['id'])
                        if self.antispam and not self.antispam.check_contact(contact):
                            self.logger.info('Skipped a spam-basket from %s' % contact.name)
                            self.report_spam(basket['who']['id'])
                            continue

                        thread = Thread(int(basket['who']['id']))
                        thread.title = 'Basket of %s' % contact.name
                        thread.root = Message(thread=thread,
                                              id=self.MAGIC_ID_BASKET,
                                              title=thread.title,
                                              sender=contact.name,
                                              receivers=[my_name],
                                              date=parse_dt(basket['date']),
                                              content='You are taken in her basket!',
                                              signature=contact.get_text(),
                                              children=[],
                                              flags=Message.IS_UNREAD)
                        yield thread.root
        except BrowserUnavailable as e:
            self.logger.debug('No messages, browser is unavailable: %s' % e)
            pass  # don't care about waiting

 def iter_threads(self):
     for msg in self.browser.iter_dates():
         thread = Thread(msg.id)
         thread.title = msg.title
         thread.date = msg.date
         thread.root = msg
         msg.thread = thread
         yield thread

    def iter_threads(self):
        for thread in self.browser.get_threads():
            if not "person" in thread:
                # The account has been removed, probably because it was a
                # spammer.
                continue

            t = Thread(thread["_id"])
            t.flags = Thread.IS_DISCUSSION
            t.title = u"Discussion with %s" % thread["person"]["name"]
            contact = self.storage.get("contacts", t.id, default={"lastmsg": 0})

            birthday = parse_date(thread["person"]["birth_date"]).date()
            signature = u"Age: %d (%s)" % ((datetime.date.today() - birthday).days / 365.25, birthday)
            signature += u"\nLast ping: %s" % parse_date(thread["person"]["ping_time"]).strftime("%Y-%m-%d %H:%M:%S")
            signature += u"\nPhotos:\n\t%s" % "\n\t".join([photo["url"] for photo in thread["person"]["photos"]])
            signature += u"\n\n%s" % thread["person"]["bio"]

            t.root = Message(
                thread=t,
                id=1,
                title=t.title,
                sender=unicode(thread["person"]["name"]),
                receivers=[self.browser.my_name],
                date=parse_date(thread["created_date"]),
                content=u"Match!",
                children=[],
                signature=signature,
                flags=Message.IS_UNREAD if int(contact["lastmsg"]) < 1 else 0,
            )
            parent = t.root

            for msg in thread["messages"]:
                flags = 0
                if int(contact["lastmsg"]) < msg["timestamp"]:
                    flags = Message.IS_UNREAD

                msg = Message(
                    thread=t,
                    id=msg["timestamp"],
                    title=t.title,
                    sender=unicode(
                        self.browser.my_name if msg["from"] == self.browser.my_id else thread["person"]["name"]
                    ),
                    receivers=[
                        unicode(self.browser.my_name if msg["to"] == self.browser.my_id else thread["person"]["name"])
                    ],
                    date=parse_date(msg["sent_date"]),
                    content=unicode(msg["message"]),
                    children=[],
                    parent=parent,
                    signature=signature if msg["to"] == self.browser.my_id else u"",
                    flags=flags,
                )
                parent.children.append(msg)
                parent = msg

            yield t

    def iter_threads(self):
        threads = self.browser.get_threads_list()

        for thread in threads:
            t = Thread(thread['userid'])
            t.flags = Thread.IS_DISCUSSION
            t.title = u'Discussion with %s' % thread['user']['username']
            t.date = datetime.fromtimestamp(thread['timestamp'])
            yield t

    def get_thread(self, thread):
        if not isinstance(thread, Thread):
            thread = Thread(thread)
            thread.flags = Thread.IS_DISCUSSION

        user = self.browser.get_user(thread.id)
        thread.title = u'Discussion with %s' % user['name']

        contact = self.storage.get('contacts', thread.id, default={'lastmsg': 0})

        signature = u'Age: %s' % user['age']
        signature += u'\nLast online: %s' % user['last_online']
        signature += u'\nPhotos:\n\t%s' % '\n\t'.join([user['photo_host'] + photo['large'] for photo in user['photos']])

        child = None

        for msg in self.browser.get_thread_messages(thread.id):
            flags = 0
            if int(contact['lastmsg']) < msg['utc_timestamp']:
                flags = Message.IS_UNREAD

            if msg['type'] == 'msg':
                content = unicode(msg['msg'])
            elif msg['type'] == 'new_challenge':
                content = u'A new challenge has been proposed!'
            elif msg['type'] == 'serie':
                content = u"I've played"
            elif msg['type'] == 'end_game':
                content = u'%s is the winner! (%s VS %s)' % (self.browser.my_name if msg['score']['w'] == self.browser.my_id else user['name'], msg['score']['s'][0], msg['score']['s'][1])
            else:
                content = u'Unknown action: %s' % msg['type']

            msg = Message(thread=thread,
                          id=msg['utc_timestamp'],
                          title=thread.title,
                          sender=unicode(self.browser.my_name if msg['from'] == self.browser.my_id else user['name']),
                          receivers=[unicode(self.browser.my_name if msg['from'] != self.browser.my_id else user['name'])],
                          date=local2utc(datetime.datetime.fromtimestamp(msg['utc_timestamp'])),
                          content=content,
                          children=[],
                          parent=None,
                          signature=signature if msg['from'] != self.browser.my_id else u'',
                          flags=flags)

            if child:
                msg.children.append(child)
                child.parent = msg
            child = msg
        thread.root = child

        return thread

    def _iter_threads(self, root_link=None):
        links = list(self.browser.iter_links(root_link.url if root_link else None))

        for link in links:
            if link.type == link.FORUM:
                link.title = '%s[%s]' % (root_link.title if root_link else '', link.title)
                for thread in self._iter_threads(link):
                    yield thread
            if link.type == link.TOPIC:
                thread = Thread(url2id(link.url))
                thread.title = ('%s ' % root_link.title if root_link else '') + link.title
                thread.date = link.date
                thread.flags = thread.IS_DISCUSSION
                yield thread

    def iter_threads(self):
        with self.browser:
            threads = self.browser.get_threads_list()

        for thread in threads:
            # Remove messages from user that quit
            # if thread['member'].get('isBan', thread['member'].get('dead', False)):
            #    with self.browser:
            #        self.browser.delete_thread(thread['member']['id'])
            #    continue
            t = Thread(int(thread["id"]))
            t.flags = Thread.IS_DISCUSSION
            t.title = u"Discussion with %s" % thread["username"]
            yield t

    def get_thread(self, id, getseen=True):
        if not isinstance(id, Thread):
            thread = None
        else:
            thread = id
            id = thread.id

            # Check if we have seen all comments of this thread.
            oldhash = self.storage.get('hash', id, default="")
            newhash = self.browser.get_hash(thread._rsscomment)
            if not getseen and oldhash == newhash:
                return None
            self.storage.set('hash', id, newhash)
            if thread.date:
                self.storage.set('date', id, thread.date)
            self.storage.save()

        with self.browser:
            content = self.browser.get_content(id)

        if not content:
            return None

        if not thread:
            thread = Thread(content.id)

        flags = Message.IS_HTML
        if not thread.id in self.storage.get('seen', default={}):
            flags |= Message.IS_UNREAD

        thread.title = content.title
        if not thread.date:
            thread.date = content.date

        thread.root = Message(thread=thread,
                              id='0',  # root message
                              title=content.title,
                              sender=content.author or u'',
                              receivers=None,
                              date=thread.date,
                              parent=None,
                              content=content.body,
                              signature='URL: %s' % self.browser.absurl(id2url(content.id)),
                              children=[],
                              flags=flags)

        for com in content.comments:
            self._insert_comment(com, thread.root, getseen)

        return thread

    def iter_threads(self):
        whats = set()
        if self.config['get_news']:
            whats.add(self.RSS_NEWSPAPERS)
        if self.config['get_telegrams']:
            whats.add(self.RSS_TELEGRAMS)


        for what in whats:
            for article in Newsfeed(what, url2id).iter_entries():
                thread = Thread(article.id)
                thread.title = article.title
                if article.datetime:
                    thread.date = article.datetime
                yield thread

    def iter_threads_list(self):
        # site is sorted from latest to oldest
        for message_a in reversed(self.document.findAll('a', href=re.compile(r'message_read.php\?'))):
            ovs_id = re.search(r'Id=(\d+)', message_a["href"]).group(1)
            id_ = ovs_id

            thread = Thread(id_)
            thread.title = ovsparse.all_text_recursive(message_a)
            thread.flags = Thread.IS_DISCUSSION

            #~ parent_tr = message_a.findParent('tr')
            #~ username = all_text_recursive(parent_tr.find('a', href=re.compile(r'profil_read.php\?.*')))
            #~ notread_self = (parent_tr.get('class') == 'newmails')
            #~ notread_other = (parent_tr.find('span', **{'class': 'new_sortiepartenaire'}) is not None)

            yield thread

    def get_thread(self, id, getseen=True):
        if not isinstance(id, Thread):
            thread = None
        else:
            thread = id
            id = thread.id

            if thread.date:
                self.storage.set("date", id, thread.date)
                self.storage.save()

        with self.browser:
            content = self.browser.get_content(id)

        if not content:
            return None

        if not thread:
            thread = Thread(content.id)

        flags = Message.IS_HTML
        if not thread.id in self.storage.get("seen", default={}):
            flags |= Message.IS_UNREAD

        thread.title = content.title
        if not thread.date:
            thread.date = content.date

        thread.root = Message(
            thread=thread,
            id="0",  # root message
            title=content.title,
            sender=content.author or u"",
            receivers=None,
            date=thread.date,
            parent=None,
            content=content.body,
            signature="URL: %s" % self.browser.absurl(id2url(content.id)),
            children=[],
            flags=flags,
        )

        for com in content.comments:
            self._insert_comment(com, thread.root, getseen)

        return thread